odxtools 7.2.0__py3-none-any.whl → 7.4.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/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/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
         #####
@@ -175,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)
@@ -294,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
@@ -412,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]:
@@ -712,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"]:
@@ -762,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)]
 
@@ -1200,16 +1200,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 +1223,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()}."