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

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/diagnostictroublecode.py

@@ -1,6 +1,6 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import Any, Dict, List, Optional, Union
+from typing import Any, Dict, List, Optional
 from xml.etree import ElementTree
 
 from .element import IdentifiableElement
@@ -17,7 +17,7 @@ class DiagnosticTroubleCode(IdentifiableElement):
     trouble_code: int
     text: Optional[str]
     display_trouble_code: Optional[str]
-    level: Union[int, None]
+    level: Optional[int]
     is_temporary_raw: Optional[bool]
     sdgs: List[SpecialDataGroup]
 

odxtools/diagservice.py

@@ -6,7 +6,7 @@ from xml.etree import ElementTree
 
 from .comparaminstance import ComparamInstance
 from .diagcomm import DiagComm
-from .exceptions import DecodeError, odxassert, odxraise, odxrequire
+from .exceptions import DecodeError, DecodeMismatch, odxassert, odxraise, odxrequire
 from .message import Message
 from .nameditemlist import NamedItemList
 from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef
@@ -42,7 +42,7 @@ class DiagService(DiagComm):
     pos_response_refs: List[OdxLinkRef]
     neg_response_refs: List[OdxLinkRef]
 
-    # TODO: pos_response_suppressable: Optional[PosResponseSuppressable]
+    # TODO: pos_response_suppressable: Optional[PosResponseSuppressable] # (sic!)
 
     is_cyclic_raw: Optional[bool]
     is_multiple_raw: Optional[bool]
@@ -181,8 +181,9 @@ class DiagService(DiagComm):
         for cpr in self.comparam_refs:
             cpr._resolve_snrefs(context)
 
-        # comparams named list is lazy loaded
-        # since ComparamInstance short_name is only valid after resolution
+        # The named item list of communication parameters is created
+        # here because ComparamInstance.short_name is only valid after
+        # reference resolution
         self._comparams = NamedItemList(self.comparam_refs)
 
         context.diag_service = None
@@ -202,24 +203,36 @@ class DiagService(DiagComm):
             if len(raw_message) >= len(prefix) and prefix == raw_message[:len(prefix)]:
                 coding_objects.append(candidate_coding_object)
 
-        if len(coding_objects) != 1:
-            raise DecodeError(
-                f"The service {self.short_name} cannot decode the message {raw_message.hex()}")
-        coding_object = coding_objects[0]
-        param_dict = coding_object.decode(raw_message)
-        if not isinstance(param_dict, dict):
-            # if this happens, this is probably due to a bug in
-            # coding_object.decode()
-            raise RuntimeError(f"Expected a set of decoded parameters, got {type(param_dict)}")
-        return Message(
-            coded_message=raw_message,
-            service=self,
-            coding_object=coding_object,
-            param_dict=param_dict)
+        result_list: List[Message] = []
+        for coding_object in coding_objects:
+            try:
+                result_list.append(
+                    Message(
+                        coded_message=raw_message,
+                        service=self,
+                        coding_object=coding_object,
+                        param_dict=coding_object.decode(raw_message)))
+            except DecodeMismatch:
+                # An NRC-CONST or environment data parameter
+                # encountered a non-matching value -> coding object
+                # does not apply
+                pass
+
+        if len(result_list) < 1:
+            odxraise(f"The service {self.short_name} cannot decode the message {raw_message.hex()}",
+                     DecodeError)
+            return Message(
+                coded_message=raw_message, service=self, coding_object=None, param_dict={})
+        elif len(result_list) > 1:
+            odxraise(
+                f"The service {self.short_name} cannot uniquely decode the message {raw_message.hex()}",
+                DecodeError)
+
+        return result_list[0]
 
     def encode_request(self, **kwargs: ParameterValue) -> bytes:
-        """
-        Composes an UDS request an array of bytes for this service.
+        """Prepare an array of bytes ready to be send over the wire
+        for the request of this service.
         """
         # make sure that all parameters which are required for
         # encoding are specified (parameters which have a default are

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)

odxtools/dtcdop.py

@@ -130,24 +130,49 @@ class DtcDop(DopBase):
             sdgs=[],
         )
 
-    @override
-    def encode_into_pdu(self, physical_value: Optional[ParameterValue],
-                        encode_state: EncodeState) -> None:
-        if isinstance(physical_value, DiagnosticTroubleCode):
-            trouble_code = physical_value.trouble_code
-        elif isinstance(physical_value, int):
+    def convert_to_numerical_trouble_code(self, dtc_value: ParameterValue) -> int:
+        if isinstance(dtc_value, DiagnosticTroubleCode):
+            return dtc_value.trouble_code
+        elif isinstance(dtc_value, int):
             # assume that physical value is the trouble_code
-            trouble_code = physical_value
-        elif isinstance(physical_value, str):
+            return dtc_value
+        elif isinstance(dtc_value, str):
             # assume that physical value is the short_name
-            dtcs = [dtc for dtc in self.dtcs if dtc.short_name == physical_value]
-            odxassert(len(dtcs) == 1)
-            trouble_code = dtcs[0].trouble_code
+            dtcs = [dtc for dtc in self.dtcs if dtc.short_name == dtc_value]
+            if len(dtcs) != 1:
+                odxraise(f"No DTC named {dtc_value} found for DTC-DOP "
+                         f"{self.short_name}.", EncodeError)
+                return cast(int, None)
+
+            return dtcs[0].trouble_code
         else:
-            raise EncodeError(f"The DTC-DOP {self.short_name} expected a"
-                              f" DiagnosticTroubleCode but got {physical_value!r}.")
+            odxraise(
+                f"The DTC-DOP {self.short_name} expected a"
+                f" diagnostic trouble code but got {type(dtc_value).__name__}", EncodeError)
+            return cast(int, None)
+
+    @override
+    def encode_into_pdu(self, physical_value: Optional[ParameterValue],
+                        encode_state: EncodeState) -> None:
+        if physical_value is None:
+            odxraise(f"No DTC specified", EncodeError)
+            return
+
+        trouble_code = self.convert_to_numerical_trouble_code(physical_value)
+
+        internal_trouble_code = int(self.compu_method.convert_physical_to_internal(trouble_code))
+
+        found = False
+        for dtc in self.dtcs:
+            if internal_trouble_code == dtc.trouble_code:
+                found = True
+                break
+
+        if not found:
+            odxraise(
+                f"Unknown diagnostic trouble code {physical_value!r} "
+                f"(0x{internal_trouble_code: 06x}) specified", EncodeError)
 
-        internal_trouble_code = self.compu_method.convert_physical_to_internal(trouble_code)
         self.diag_coded_type.encode_into_pdu(internal_trouble_code, encode_state)
 
     def _build_odxlinks(self) -> Dict[OdxLinkId, Any]: