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

odxtools/basicstructure.py

@@ -10,7 +10,7 @@ from .complexdop import ComplexDop
 from .dataobjectproperty import DataObjectProperty
 from .decodestate import DecodeState
 from .encodestate import EncodeState
-from .exceptions import EncodeError, OdxWarning, odxassert, odxraise, strict_mode
+from .exceptions import EncodeError, OdxWarning, odxassert, odxraise
 from .nameditemlist import NamedItemList
 from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
 from .odxtypes import ParameterDict, ParameterValue, ParameterValueDict
@@ -18,7 +18,6 @@ from .parameters.codedconstparameter import CodedConstParameter
 from .parameters.createanyparameter import create_any_parameter_from_et
 from .parameters.lengthkeyparameter import LengthKeyParameter
 from .parameters.matchingrequestparameter import MatchingRequestParameter
-from .parameters.nrcconstparameter import NrcConstParameter
 from .parameters.parameter import Parameter
 from .parameters.parameterwithdop import ParameterWithDOP
 from .parameters.physicalconstantparameter import PhysicalConstantParameter
@@ -75,10 +74,11 @@ class BasicStructure(ComplexDop):
 
         for param in self.parameters:
             if (isinstance(param, MatchingRequestParameter) and param.request_byte_position < len(request_prefix)) or \
-                isinstance(param, (CodedConstParameter, NrcConstParameter, PhysicalConstantParameter)):
+                isinstance(param, (CodedConstParameter, PhysicalConstantParameter)):
                 param.encode_into_pdu(physical_value=None, encode_state=encode_state)
             else:
                 break
+
         return encode_state.coded_message
 
     @property
@@ -160,8 +160,8 @@ class BasicStructure(ComplexDop):
         orig_is_end_of_pdu = encode_state.is_end_of_pdu
         encode_state.is_end_of_pdu = False
 
-        # in strict mode, ensure that no values for unknown parameters are specified.
-        if strict_mode:
+        # ensure that no values for unknown parameters are specified.
+        if not encode_state.allow_unknown_parameters:
             param_names = {param.short_name for param in self.parameters}
             for param_value_name in physical_value:
                 if param_value_name not in param_names:
@@ -193,8 +193,10 @@ class BasicStructure(ComplexDop):
                 odxraise(f"No value for required parameter {param.short_name} specified",
                          EncodeError)
 
-            param.encode_into_pdu(
-                physical_value=physical_value.get(param.short_name), encode_state=encode_state)
+            param_phys_value = physical_value.get(param.short_name)
+            param.encode_into_pdu(physical_value=param_phys_value, encode_state=encode_state)
+
+            encode_state.journal.append((param, param_phys_value))
 
         encode_state.is_end_of_pdu = False
         if self.byte_size is not None:
@@ -236,6 +238,7 @@ class BasicStructure(ComplexDop):
         for param in self.parameters:
             value = param.decode_from_pdu(decode_state)
 
+            decode_state.journal.append((param, value))
             result[param.short_name] = value
 
         # decoding of the structure finished. go back the original origin.

odxtools/compumethods/linearsegment.py

@@ -46,8 +46,6 @@ class LinearSegment:
 
         inverse_value: Union[int, float] = 0
         if scale.compu_inverse_value is not None:
-            if abs(factor) < 1e-10:
-                odxraise(f"COMPU-INVERSE-VALUE for non-zero slope ({factor}) defined")
             x = odxrequire(scale.compu_inverse_value).value
             if not isinstance(x, (int, float)):
                 odxraise(f"Non-numeric COMPU-INVERSE-VALUE specified ({x!r})")

odxtools/database.py

@@ -1,7 +1,7 @@
 # SPDX-License-Identifier: MIT
 from itertools import chain
 from pathlib import Path
-from typing import IO, List, Optional, OrderedDict
+from typing import IO, Any, Dict, List, Optional, OrderedDict
 from xml.etree import ElementTree
 from zipfile import ZipFile
 
@@ -13,7 +13,7 @@ from .diaglayer import DiagLayer
 from .diaglayercontainer import DiagLayerContainer
 from .exceptions import odxraise
 from .nameditemlist import NamedItemList
-from .odxlink import OdxLinkDatabase
+from .odxlink import OdxLinkDatabase, OdxLinkId
 
 
 class Database:
@@ -108,15 +108,7 @@ class Database:
 
         # Build odxlinks
         self._odxlinks = OdxLinkDatabase()
-
-        for subset in self.comparam_subsets:
-            self._odxlinks.update(subset._build_odxlinks())
-
-        for spec in self.comparam_specs:
-            self._odxlinks.update(spec._build_odxlinks())
-
-        for dlc in self.diag_layer_containers:
-            self._odxlinks.update(dlc._build_odxlinks())
+        self._odxlinks.update(self._build_odxlinks())
 
         # Resolve ODXLINK references
         for subset in self.comparam_subsets:
@@ -133,6 +125,20 @@ class Database:
         for dlc in self.diag_layer_containers:
             dlc._finalize_init(self, self._odxlinks)
 
+    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+        result: Dict[OdxLinkId, Any] = {}
+
+        for subset in self.comparam_subsets:
+            result.update(subset._build_odxlinks())
+
+        for spec in self.comparam_specs:
+            result.update(spec._build_odxlinks())
+
+        for dlc in self.diag_layer_containers:
+            result.update(dlc._build_odxlinks())
+
+        return result
+
     @property
     def odxlinks(self) -> OdxLinkDatabase:
         """A map from odx_id to object"""

odxtools/decodestate.py

@@ -1,11 +1,11 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass, field
-from typing import TYPE_CHECKING, Dict, cast
+from typing import TYPE_CHECKING, Dict, List, Optional, Tuple, cast
 
 import odxtools.exceptions as exceptions
 
 from .exceptions import DecodeError
-from .odxtypes import AtomicOdxType, DataType
+from .odxtypes import AtomicOdxType, DataType, ParameterValue
 
 try:
     import bitstruct.c as bitstruct
@@ -13,6 +13,7 @@ except ImportError:
     import bitstruct
 
 if TYPE_CHECKING:
+    from .parameters.parameter import Parameter
     from .tablerow import TableRow
 
 
@@ -46,6 +47,11 @@ class DecodeState:
     #: values of the table key parameters decoded so far
     table_keys: Dict[str, "TableRow"] = field(default_factory=dict)
 
+    #: List of parameters that have been decoded so far. The journal
+    #: is used by some types of parameters which depend on the values of
+    #: other parameters; i.e., environment data description parameters
+    journal: List[Tuple["Parameter", Optional[ParameterValue]]] = field(default_factory=list)
+
     def extract_atomic_value(
         self,
         bit_length: int,

odxtools/diaglayer.py

@@ -161,11 +161,6 @@ class DiagLayer:
         excessive memory consumption for large databases...
         """
 
-        # this attribute may be removed later. it is currently
-        # required to properly deal with auxiliary files within the
-        # diagnostic layer.
-        self._database = database
-
         #####
         # fill in all applicable objects that use value inheritance
         #####
@@ -1200,16 +1195,19 @@ class DiagLayer:
         for service in candidate_services:
             try:
                 decoded_messages.append(service.decode_message(message))
-            except DecodeError:
+            except DecodeError as e:
                 # check if the message can be decoded as a global
                 # negative response for the service
+                gnr_found = False
                 for gnr in self.global_negative_responses:
                     try:
                         decoded_gnr = gnr.decode(message)
+                        gnr_found = True
                         if not isinstance(decoded_gnr, dict):
-                            raise DecodeError(f"Expected the decoded value of a global "
-                                              f"negative response to be a dictionary, "
-                                              f"got {type(decoded_gnr)} for {self.short_name}")
+                            odxraise(
+                                f"Expected the decoded value of a global "
+                                f"negative response to be a dictionary, "
+                                f"got {type(decoded_gnr)} for {self.short_name}", DecodeError)
 
                         decoded_messages.append(
                             Message(
@@ -1220,6 +1218,9 @@ class DiagLayer:
                     except DecodeError:
                         pass
 
+                if not gnr_found:
+                    raise e
+
         if len(decoded_messages) == 0:
             raise DecodeError(
                 f"None of the services {[x.short_name for x in candidate_services]} could parse {message.hex()}."

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/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]:

odxtools/encodestate.py

@@ -1,16 +1,19 @@
 # SPDX-License-Identifier: MIT
 import warnings
 from dataclasses import dataclass, field
-from typing import Dict, Optional, SupportsBytes
+from typing import TYPE_CHECKING, Dict, List, Optional, SupportsBytes, Tuple
 
 from .exceptions import EncodeError, OdxWarning, odxassert, odxraise
-from .odxtypes import AtomicOdxType, DataType
+from .odxtypes import AtomicOdxType, DataType, ParameterValue
 
 try:
     import bitstruct.c as bitstruct
 except ImportError:
     import bitstruct
 
+if TYPE_CHECKING:
+    from .parameters.parameter import Parameter
+
 
 @dataclass
 class EncodeState:
@@ -56,6 +59,15 @@ class EncodeState:
     #: (needed for MinMaxLengthType, EndOfPduField, etc.)
     is_end_of_pdu: bool = True
 
+    #: list of parameters that have been encoded so far. The journal
+    #: is used by some types of parameters which depend on the values of
+    #: other parameters; e.g., environment data description parameters
+    journal: List[Tuple["Parameter", Optional[ParameterValue]]] = field(default_factory=list)
+
+    #: If this is True, specifying unknown parameters for encoding
+    #: will raise an OdxError exception in strict mode.
+    allow_unknown_parameters = False
+
     def __post_init__(self) -> None:
         # if a coded message has been specified, but no used_mask, we
         # assume that all of the bits of the coded message are

odxtools/environmentdatadescription.py

@@ -1,17 +1,19 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import Any, Dict, List, Optional
+from typing import Any, Dict, List, Optional, cast
 from xml.etree import ElementTree
 
 from typing_extensions import override
 
 from .complexdop import ComplexDop
 from .decodestate import DecodeState
+from .dtcdop import DtcDop
 from .encodestate import EncodeState
 from .environmentdata import EnvironmentData
 from .exceptions import odxraise, odxrequire
 from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef
-from .odxtypes import ParameterValue
+from .odxtypes import ParameterValue, ParameterValueDict
+from .parameters.parameter import Parameter
 from .snrefcontext import SnRefContext
 from .utils import dataclass_fields_asdict
 
@@ -27,16 +29,26 @@ class EnvironmentDataDescription(ComplexDop):
 
     """
 
+    param_snref: Optional[str]
+    param_snpathref: Optional[str]
+
     # in ODX 2.0.0, ENV-DATAS seems to be a mandatory
     # sub-element of ENV-DATA-DESC, in ODX 2.2 it is not
     # present
     env_datas: List[EnvironmentData]
     env_data_refs: List[OdxLinkRef]
-    param_snref: Optional[str]
-    param_snpathref: Optional[str]
 
-    def __post_init__(self) -> None:
-        self.bit_length = None
+    @property
+    def param(self) -> Parameter:
+        # the parameter referenced via SNREF cannot be resolved here
+        # because the relevant list of parameters depends on the
+        # concrete codec object processed, whilst an environment data
+        # description object can be featured in an arbitrary number of
+        # responses. Instead, lookup of the appropriate parameter is
+        # done within the encode and decode methods.
+        odxraise("The parameter of ENV-DATA-DESC objects cannot be resolved "
+                 "because it depends on the context")
+        return cast(None, Parameter)
 
     @staticmethod
     def from_et(et_element: ElementTree.Element,
@@ -96,17 +108,125 @@ class EnvironmentDataDescription(ComplexDop):
     def encode_into_pdu(self, physical_value: Optional[ParameterValue],
                         encode_state: EncodeState) -> None:
         """Convert a physical value into bytes and emplace them into a PDU.
-
-        Since environmental data is supposed to never appear on the
-        wire, this method just raises an EncodeError exception.
         """
-        odxraise("EnvironmentDataDescription DOPs cannot be encoded or decoded")
+
+        # retrieve the relevant DTC parameter which must be located in
+        # front of the environment data description.
+        if self.param_snref is None:
+            odxraise("Specifying the DTC parameter for environment data "
+                     "descriptions via SNPATHREF is not supported yet")
+            return None
+
+        dtc_param: Optional[Parameter] = None
+        dtc_dop: Optional[DtcDop] = None
+        dtc_param_value: Optional[ParameterValue] = None
+        for prev_param, prev_param_value in reversed(encode_state.journal):
+            if prev_param.short_name == self.param_snref:
+                dtc_param = prev_param
+                prev_dop = getattr(prev_param, "dop", None)
+                if not isinstance(prev_dop, DtcDop):
+                    odxraise(f"The DOP of the parameter referenced by environment data "
+                             f"descriptions must be a DTC-DOP (is '{type(prev_dop).__name__}')")
+                    return
+                dtc_dop = prev_dop
+                dtc_param_value = prev_param_value
+                break
+
+        if dtc_param is None:
+            odxraise("Environment data description parameters are only allowed following "
+                     "the referenced value parameter.")
+            return
+
+        if dtc_param_value is None or dtc_dop is None:
+            # this should never happen
+            odxraise()
+            return
+
+        numerical_dtc = dtc_dop.convert_to_numerical_trouble_code(dtc_param_value)
+
+        # deal with the "all value" environment data. This holds
+        # parameters that are common to all DTCs. Be aware that the
+        # specification mandates that there is at most one such
+        # environment data object
+        for env_data in self.env_datas:
+            if env_data.all_value:
+                tmp = encode_state.allow_unknown_parameters
+                encode_state.allow_unknown_parameters = True
+                env_data.encode_into_pdu(physical_value, encode_state)
+                encode_state.allow_unknown_parameters = tmp
+                break
+
+        # find the environment data corresponding to the given trouble
+        # code
+        for env_data in self.env_datas:
+            if numerical_dtc in env_data.dtc_values:
+                tmp = encode_state.allow_unknown_parameters
+                encode_state.allow_unknown_parameters = True
+                env_data.encode_into_pdu(physical_value, encode_state)
+                encode_state.allow_unknown_parameters = tmp
+                break
 
     @override
     def decode_from_pdu(self, decode_state: DecodeState) -> ParameterValue:
         """Extract the bytes from a PDU and convert them to a physical value.
-
-        Since environmental data is supposed to never appear on the
-        wire, this method just raises an DecodeError exception.
         """
-        odxraise("EnvironmentDataDescription DOPs cannot be encoded or decoded")
+
+        # retrieve the relevant DTC parameter which must be located in
+        # front of the environment data description.
+        if self.param_snref is None:
+            odxraise("Specifying the DTC parameter for environment data "
+                     "descriptions via SNPATHREF is not supported yet")
+            return None
+
+        dtc_param: Optional[Parameter] = None
+        dtc_dop: Optional[DtcDop] = None
+        dtc_param_value: Optional[ParameterValue] = None
+        for prev_param, prev_param_value in reversed(decode_state.journal):
+            if prev_param.short_name == self.param_snref:
+                dtc_param = prev_param
+                prev_dop = getattr(prev_param, "dop", None)
+                if not isinstance(prev_dop, DtcDop):
+                    odxraise(f"The DOP of the parameter referenced by environment data "
+                             f"descriptions must be a DTC-DOP (is '{type(prev_dop).__name__}')")
+                    return
+                dtc_dop = prev_dop
+                dtc_param_value = prev_param_value
+                break
+
+        if dtc_param is None:
+            odxraise("Environment data description parameters are only allowed following "
+                     "the referenced value parameter.")
+            return
+
+        if dtc_param_value is None or dtc_dop is None:
+            # this should never happen
+            odxraise()
+            return
+
+        numerical_dtc = dtc_dop.convert_to_numerical_trouble_code(dtc_param_value)
+
+        result: ParameterValueDict = {}
+
+        # deal with the "all value" environment data. This holds
+        # parameters that are common to all DTCs. Be aware that the
+        # specification mandates that there is at most one such
+        # environment data object
+        for env_data in self.env_datas:
+            if env_data.all_value:
+                tmp = env_data.decode_from_pdu(decode_state)
+                if not isinstance(tmp, dict):
+                    odxraise()
+                result.update(tmp)
+                break
+
+        # find the environment data corresponding to the given trouble
+        # code
+        for env_data in self.env_datas:
+            if numerical_dtc in env_data.dtc_values:
+                tmp = env_data.decode_from_pdu(decode_state)
+                if not isinstance(tmp, dict):
+                    odxraise()
+                result.update(tmp)
+                break
+
+        return result

odxtools/exceptions.py

@@ -9,13 +9,22 @@ class OdxError(Exception):
 
 
 class EncodeError(Warning, OdxError):
-    """Encoding of a message to raw data failed."""
+    """Encoding of a message to raw data failed"""
 
 
 class DecodeError(Warning, OdxError):
     """Decoding raw data failed."""
 
 
+class DecodeMismatch(DecodeError):
+    """Decoding failed because some parameters exhibit an incorrect value
+
+    This is can happen if NRC-CONST or environment data descriptions
+    are present.
+
+    """
+
+
 class OdxWarning(Warning):
     """Any warning that happens during interacting with diagnostic objects."""