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

odxtools/multiplexer.py

@@ -1,6 +1,6 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import Any, Dict, List, Optional, Tuple
+from typing import Any, Dict, List, Optional, Tuple, Union, cast
 from xml.etree import ElementTree
 
 from typing_extensions import override
@@ -8,7 +8,7 @@ from typing_extensions import override
 from .complexdop import ComplexDop
 from .decodestate import DecodeState
 from .encodestate import EncodeState
-from .exceptions import DecodeError, EncodeError, odxraise, odxrequire
+from .exceptions import DecodeError, EncodeError, odxassert, odxraise, odxrequire
 from .multiplexercase import MultiplexerCase
 from .multiplexerdefaultcase import MultiplexerDefaultCase
 from .multiplexerswitchkey import MultiplexerSwitchKey
@@ -79,87 +79,123 @@ class Multiplexer(ComplexDop):
     def encode_into_pdu(self, physical_value: ParameterValue, encode_state: EncodeState) -> None:
 
         if encode_state.cursor_bit_position != 0:
-            raise EncodeError(f"Multiplexer must be aligned, i.e. bit_position=0, but "
+            raise EncodeError(f"Multiplexer parameters must be aligned, i.e. bit_position=0, but "
                               f"{self.short_name} was passed the bit position "
                               f"{encode_state.cursor_bit_position}")
 
-        if not isinstance(physical_value, dict) or len(physical_value) != 1:
-            raise EncodeError("""Multiplexer should be defined as a dict
-            with only one key equal to the desired case""")
-
         orig_origin = encode_state.origin_byte_position
-
         encode_state.origin_byte_position = encode_state.cursor_byte_position
 
-        case_name, case_value = next(iter(physical_value.items()))
-
-        for mux_case in self.cases or []:
-            if mux_case.short_name == case_name:
-                key_value, _ = self._get_case_limits(mux_case)
-
-                if self.switch_key.byte_position is not None:
-                    encode_state.cursor_byte_position = encode_state.origin_byte_position + self.switch_key.byte_position
-                encode_state.cursor_bit_position = self.switch_key.bit_position or 0
-
-                self.switch_key.dop.encode_into_pdu(
-                    physical_value=key_value, encode_state=encode_state)
-
-                if self.byte_position is not None:
-                    encode_state.cursor_byte_position = encode_state.origin_byte_position + self.byte_position
-                encode_state.cursor_bit_position = 0
-
-                if mux_case._structure is None:
-                    odxraise(f"Multiplexer case '{mux_case.short_name}' does not "
-                             f"reference a structure.")
-                    return
-
-                mux_case.structure.encode_into_pdu(
-                    physical_value=key_value, encode_state=encode_state)
-
-                encode_state.origin_byte_position = orig_origin
-                return
-
-        raise EncodeError(f"The case {case_name} is not found in Multiplexer {self.short_name}")
+        if isinstance(physical_value, (list, tuple)) and len(physical_value) == 2:
+            case_spec, case_value = physical_value
+        elif isinstance(physical_value, dict) and len(physical_value) == 1:
+            case_spec, case_value = next(iter(physical_value.items()))
+        else:
+            raise EncodeError(
+                f"Values of multiplexer parameters must be defined as a "
+                f"(case_name, content_value) tuple instead of as '{physical_value!r}'")
+
+        mux_case: Union[MultiplexerCase, MultiplexerDefaultCase]
+        if isinstance(case_spec, str):
+            applicable_cases = [x for x in self.cases if x.short_name == case_spec]
+            if len(applicable_cases) == 0:
+                raise EncodeError(
+                    f"Multiplexer {self.short_name} does not know any case called {case_spec}")
+
+            odxassert(len(applicable_cases) == 1)
+            mux_case = applicable_cases[0]
+            key_value, _ = self._get_case_limits(mux_case)
+        elif isinstance(case_spec, int):
+            applicable_cases = []
+            for x in self.cases:
+                lower, upper = cast(Tuple[int, int], self._get_case_limits(x))
+                if lower <= case_spec and case_spec <= upper:
+                    applicable_cases.append(x)
+
+            if len(applicable_cases) == 0:
+                if self.default_case is None:
+                    raise EncodeError(
+                        f"Multiplexer {self.short_name} does not know any case called {case_spec}")
+                mux_case = self.default_case
+                key_value = case_spec
+            else:
+                mux_case = applicable_cases[0]
+                key_value = case_spec
+        elif isinstance(case_spec, MultiplexerCase):
+            mux_case = case_spec
+            key_value, _ = self._get_case_limits(mux_case)
+        elif case_spec is None:
+            if self.default_case is None:
+                raise EncodeError(f"Multiplexer {self.short_name} does not define a default case")
+            key_value = 0
+        else:
+            raise EncodeError(f"Illegal case specification '{case_spec}' for "
+                              f"multiplexer {self.short_name}")
+
+        # the byte position of the switch key is relative to
+        # the multiplexer's position
+        encode_state.cursor_byte_position = encode_state.origin_byte_position + self.switch_key.byte_position
+        encode_state.cursor_bit_position = self.switch_key.bit_position or 0
+        self.switch_key.dop.encode_into_pdu(physical_value=key_value, encode_state=encode_state)
+        encode_state.cursor_bit_position = 0
+
+        if mux_case.structure is not None:
+            # the byte position of the content is specified by the
+            # BYTE-POSITION attribute of the multiplexer
+            encode_state.cursor_byte_position = encode_state.origin_byte_position + self.byte_position
+            mux_case.structure.encode_into_pdu(physical_value=case_value, encode_state=encode_state)
+
+        encode_state.origin_byte_position = orig_origin
 
     @override
     def decode_from_pdu(self, decode_state: DecodeState) -> ParameterValue:
-
-        # multiplexers are structures and thus the origin position
-        # must be moved to the start of the multiplexer
         orig_origin = decode_state.origin_byte_position
-        if self.byte_position is not None:
-            decode_state.cursor_byte_position = decode_state.origin_byte_position + self.byte_position
         decode_state.origin_byte_position = decode_state.cursor_byte_position
 
+        # Decode the switch key. Its BYTE-POSITION is relative to the
+        # that of the multiplexer.
+        if self.switch_key.byte_position is not None:
+            decode_state.cursor_byte_position = decode_state.origin_byte_position + self.switch_key.byte_position
+        decode_state.cursor_bit_position = self.switch_key.bit_position or 0
         key_value = self.switch_key.dop.decode_from_pdu(decode_state)
+        decode_state.cursor_bit_position = 0
 
         if not isinstance(key_value, int):
             odxraise(f"Multiplexer keys must be integers (is '{type(key_value).__name__}'"
                      f" for multiplexer '{self.short_name}')")
 
-        case_value: Optional[ParameterValue] = None
-        mux_case = None
-        for mux_case in self.cases or []:
+        # "If a matching CASE is found, the referenced STRUCTURE is
+        # analyzed at the BYTE-POSITION (child element of MUX)
+        # relatively to the byte position of the MUX."
+        decode_state.cursor_byte_position = decode_state.origin_byte_position + self.byte_position
+
+        applicable_case: Optional[Union[MultiplexerCase, MultiplexerDefaultCase]] = None
+        for mux_case in self.cases:
             lower, upper = self._get_case_limits(mux_case)
             if lower <= key_value and key_value <= upper:  # type: ignore[operator]
-                if mux_case._structure:
-                    case_value = mux_case._structure.decode_from_pdu(decode_state)
+                applicable_case = mux_case
                 break
 
-        if case_value is None and self.default_case is not None:
-            if self.default_case._structure:
-                case_value = self.default_case._structure.decode_from_pdu(decode_state)
+        if applicable_case is None:
+            applicable_case = self.default_case
+
+        if applicable_case is None:
+            odxraise(
+                f"Cannot find an applicable case for value {key_value} in "
+                f"multiplexer {self.short_name}", DecodeError)
+            decode_state.origin_byte_position = orig_origin
+            return (None, None)
 
-        if mux_case is None or case_value is None:
-            odxraise(f"Failed to find a matching case in {self.short_name} for value {key_value!r}",
-                     DecodeError)
+        if applicable_case.structure is not None:
+            case_value = applicable_case.structure.decode_from_pdu(decode_state)
+        else:
+            case_value = {}
 
-        mux_value = (mux_case.short_name, case_value)
+        result = (applicable_case.short_name, case_value)
 
-        # go back to the original origin
         decode_state.origin_byte_position = orig_origin
 
-        return mux_value
+        return result
 
     @override
     def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:

odxtools/multiplexercase.py

@@ -3,13 +3,13 @@ from dataclasses import dataclass
 from typing import Any, Dict, List, Optional
 from xml.etree import ElementTree
 
-from .basicstructure import BasicStructure
 from .compumethods.limit import Limit
 from .element import NamedElement
 from .exceptions import odxrequire
 from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef, resolve_snref
 from .odxtypes import AtomicOdxType, DataType
 from .snrefcontext import SnRefContext
+from .structure import Structure
 from .utils import dataclass_fields_asdict
 
 
@@ -23,7 +23,7 @@ class MultiplexerCase(NamedElement):
     upper_limit: Limit
 
     def __post_init__(self) -> None:
-        self._structure: BasicStructure
+        self._structure: Optional[Structure]
 
     @staticmethod
     def from_et(et_element: ElementTree.Element,
@@ -62,8 +62,9 @@ class MultiplexerCase(NamedElement):
 
     def _mux_case_resolve_odxlinks(self, odxlinks: OdxLinkDatabase, *,
                                    key_physical_type: DataType) -> None:
+        self._structure = None
         if self.structure_ref:
-            self._structure = odxlinks.resolve(self.structure_ref)
+            self._structure = odxlinks.resolve(self.structure_ref, Structure)
 
         self.lower_limit.set_value_type(key_physical_type)
         self.upper_limit.set_value_type(key_physical_type)
@@ -71,12 +72,12 @@ class MultiplexerCase(NamedElement):
     def _resolve_snrefs(self, context: SnRefContext) -> None:
         if self.structure_snref:
             ddds = odxrequire(context.diag_layer).diag_data_dictionary_spec
-            self._structure = resolve_snref(self.structure_snref, ddds.structures, BasicStructure)
+            self._structure = resolve_snref(self.structure_snref, ddds.structures, Structure)
 
     def applies(self, value: AtomicOdxType) -> bool:
         return self.lower_limit.complies_to_lower(value) \
             and self.upper_limit.complies_to_upper(value)
 
     @property
-    def structure(self) -> BasicStructure:
+    def structure(self) -> Optional[Structure]:
         return self._structure

odxtools/multiplexerdefaultcase.py

@@ -3,11 +3,11 @@ from dataclasses import dataclass
 from typing import Any, Dict, List, Optional
 from xml.etree import ElementTree
 
-from .basicstructure import BasicStructure
 from .element import NamedElement
 from .exceptions import odxrequire
 from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef, resolve_snref
 from .snrefcontext import SnRefContext
+from .structure import Structure
 from .utils import dataclass_fields_asdict
 
 
@@ -18,12 +18,12 @@ class MultiplexerDefaultCase(NamedElement):
     structure_snref: Optional[str]
 
     def __post_init__(self) -> None:
-        self._structure: BasicStructure
+        self._structure: Optional[Structure]
 
     @staticmethod
     def from_et(et_element: ElementTree.Element,
                 doc_frags: List[OdxDocFragment]) -> "MultiplexerDefaultCase":
-        """Reads a Default Case for a Multiplexer."""
+        """Reads a default case for a multiplexer."""
         kwargs = dataclass_fields_asdict(NamedElement.from_et(et_element, doc_frags))
 
         structure_ref = OdxLinkRef.from_et(et_element.find("STRUCTURE-REF"), doc_frags)
@@ -38,14 +38,15 @@ class MultiplexerDefaultCase(NamedElement):
         return {}
 
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
+        self._structure = None
         if self.structure_ref is not None:
-            self._structure = odxlinks.resolve(self.structure_ref)
+            self._structure = odxlinks.resolve(self.structure_ref, Structure)
 
     def _resolve_snrefs(self, context: SnRefContext) -> None:
         if self.structure_snref:
             ddds = odxrequire(context.diag_layer).diag_data_dictionary_spec
-            self._structure = resolve_snref(self.structure_snref, ddds.structures, BasicStructure)
+            self._structure = resolve_snref(self.structure_snref, ddds.structures, Structure)
 
     @property
-    def structure(self) -> BasicStructure:
+    def structure(self) -> Optional[Structure]:
         return self._structure

odxtools/odxlink.py

@@ -26,7 +26,6 @@ class OdxDocFragment:
         return self.doc_name == other.doc_name
 
     def __hash__(self) -> int:
-        # only the document name is relevant for the hash value
         return hash(self.doc_name) + hash(self.doc_type)
 
 
@@ -59,10 +58,12 @@ class OdxLinkId:
         if not isinstance(other, OdxLinkId):
             return False
 
-        # we do take the document fragment into consideration here, because
-        # document fragments are handled using separate sub-databases,
-        # i.e. the same OdxId object can be put into all of them.
-        return self.local_id == other.local_id
+        # if the local ID is different, the whole id is different
+        if self.local_id != other.local_id:
+            return False
+
+        # the document fragments must be identical for the IDs to be identical
+        return self.doc_fragments == other.doc_fragments
 
     def __str__(self) -> str:
         return f"OdxLinkId('{self.local_id}')"
@@ -147,19 +148,6 @@ class OdxLinkRef:
     def __str__(self) -> str:
         return f"OdxLinkRef('{self.ref_id}')"
 
-    def __contains__(self, odx_id: OdxLinkId) -> bool:
-        """
-        Returns true iff a given OdxLinkId object is referenced.
-        """
-
-        # we must reference at to at least of the ID's document
-        # fragments
-        if not any(ref_doc in odx_id.doc_fragments for ref_doc in self.ref_docs):
-            return False
-
-        # the local ID of the reference and the object ID must match
-        return odx_id.local_id == self.ref_id
-
 
 T = TypeVar("T")
 
@@ -172,7 +160,7 @@ class OdxLinkDatabase:
     """
 
     def __init__(self) -> None:
-        self._db: Dict[OdxDocFragment, Dict[OdxLinkId, Any]] = {}
+        self._db: Dict[OdxDocFragment, Dict[str, Any]] = {}
 
     @overload
     def resolve(self, ref: OdxLinkRef, expected_type: None = None) -> Any:
@@ -189,7 +177,6 @@ class OdxLinkDatabase:
         If the database does not contain any object which is referred to, a
         KeyError exception is raised.
         """
-        odx_id = OdxLinkId(ref.ref_id, ref.ref_docs)
         for ref_frag in reversed(ref.ref_docs):
             doc_frag_db = self._db.get(ref_frag)
             if doc_frag_db is None:
@@ -204,8 +191,9 @@ class OdxLinkDatabase:
                 )
                 continue
 
-            obj = doc_frag_db.get(odx_id)
-            if obj is not None:
+            # locate an object exhibiting with the referenced local ID
+            # in the ID database for the document fragment
+            if (obj := doc_frag_db.get(ref.ref_id)) is not None:
                 if expected_type is not None:
                     odxassert(isinstance(obj, expected_type))
 
@@ -234,7 +222,6 @@ class OdxLinkDatabase:
         is returned.
         """
 
-        odx_id = OdxLinkId(ref.ref_id, ref.ref_docs)
         for ref_frag in reversed(ref.ref_docs):
             doc_frag_db = self._db.get(ref_frag)
             if doc_frag_db is None:
@@ -249,8 +236,7 @@ class OdxLinkDatabase:
                 )
                 continue
 
-            obj = doc_frag_db.get(odx_id)
-            if obj is not None:
+            if (obj := doc_frag_db.get(ref.ref_id)) is not None:
                 if expected_type is not None:
                     odxassert(isinstance(obj, expected_type))
 
@@ -272,7 +258,7 @@ class OdxLinkDatabase:
                 if doc_frag not in self._db:
                     self._db[doc_frag] = {}
 
-                self._db[doc_frag][odx_id] = obj
+                self._db[doc_frag][odx_id.local_id] = obj
 
 
 @overload

odxtools/odxtypes.py

@@ -235,7 +235,7 @@ class DataType(Enum):
         expected_type = self.python_type
         if isinstance(value, expected_type):
             return True
-        elif expected_type == float and isinstance(value, (int, float)):
+        elif expected_type is float and isinstance(value, (int, float)):
             return True
         elif self == DataType.A_BYTEFIELD and isinstance(value, (bytearray, bytes)):
             return True

odxtools/parameterinfo.py

@@ -108,8 +108,8 @@ def parameter_info(param_list: Iterable[Parameter], quoted_names: bool = False)
             of.write(f"multiplexer; choices:\n")
             for mux_case in dop.cases:
                 of.write(f"  ({repr(mux_case.short_name)}, {{\n")
-                of.write(
-                    textwrap.indent(parameter_info(mux_case.structure.parameters, True), "    "))
+                if (struc := mux_case.structure) is not None:
+                    of.write(textwrap.indent(parameter_info(struc.parameters, True), "    "))
                 of.write(f"   }})\n")
             continue
 

odxtools/parameters/nrcconstparameter.py

@@ -1,7 +1,6 @@
 # SPDX-License-Identifier: MIT
-import warnings
 from dataclasses import dataclass
-from typing import Any, Dict, List, Optional, cast
+from typing import Any, Dict, List, Optional
 from xml.etree import ElementTree
 
 from typing_extensions import override
@@ -10,7 +9,7 @@ from ..createanydiagcodedtype import create_any_diag_coded_type_from_et
 from ..decodestate import DecodeState
 from ..diagcodedtype import DiagCodedType
 from ..encodestate import EncodeState
-from ..exceptions import DecodeError, EncodeError, odxraise, odxrequire
+from ..exceptions import DecodeMismatch, EncodeError, odxraise, odxrequire
 from ..odxlink import OdxDocFragment, OdxLinkId
 from ..odxtypes import AtomicOdxType, DataType, ParameterValue
 from ..utils import dataclass_fields_asdict
@@ -19,7 +18,8 @@ from .parameter import Parameter, ParameterType
 
 @dataclass
 class NrcConstParameter(Parameter):
-    """A param of type NRC-CONST defines a set of values to be matched for a negative response to apply.
+    """A parameter of type NRC-CONST defines a set of values to be
+    matched for a negative response object to apply
 
     The behaviour of NRC-CONST parameters is similar to CODED-CONST
     parameters in that they allow to specify which coding objects
@@ -88,49 +88,40 @@ class NrcConstParameter(Parameter):
     @override
     def _encode_positioned_into_pdu(self, physical_value: Optional[ParameterValue],
                                     encode_state: EncodeState) -> None:
-        coded_value: ParameterValue
+        # NRC-CONST parameters are not encoding any value on its
+        # own. instead, it is supposed to overlap with a value
+        # parameter.
         if physical_value is not None:
-            if physical_value not in self.coded_values:
-                odxraise(
-                    f"The value of parameter '{self.short_name}' must "
-                    f" be one of {self.coded_values} (is: {physical_value!r})", EncodeError)
-                coded_value = self.coded_values[0]
-            else:
-                coded_value = physical_value
-        else:
-            # If the user did not select a value, the value of the
-            # this parameter is set by another parameter which
-            # overlaps with it. We thus just move the cursor.
-            bit_pos = encode_state.cursor_bit_position
-            bit_len = self.diag_coded_type.get_static_bit_length()
-
-            if bit_len is None:
-                odxraise("The diag coded type of NRC-CONST parameters must "
-                         "exhibit a static size")
-                return
-
-            encode_state.cursor_byte_position += (bit_pos + bit_len + 7) // 8
-            encode_state.cursor_bit_position = 0
+            odxraise("The value of NRC-CONST parameters cannot be set directly!", EncodeError)
+
+        # TODO (?): extract the parameter and check if it is one of
+        # the values of self.coded_values. if not, throw an
+        # EncodeMismatch exception! This is probably a bad idea
+        # because the parameter which determines the value of the
+        # NRC-CONST might possibly be specified after the NRC-CONST.
+
+        # move the cursor forward by the size of the parameter
+        bit_pos = encode_state.cursor_bit_position
+        bit_len = self.diag_coded_type.get_static_bit_length()
+
+        if bit_len is None:
+            odxraise("The diag coded type of NRC-CONST parameters must "
+                     "exhibit a static size")
             return
 
-        self.diag_coded_type.encode_into_pdu(cast(AtomicOdxType, coded_value), encode_state)
+        encode_state.cursor_byte_position += (bit_pos + bit_len + 7) // 8
+        encode_state.cursor_bit_position = 0
+
+        encode_state.emplace_bytes(b'', self.short_name)
 
     @override
     def _decode_positioned_from_pdu(self, decode_state: DecodeState) -> AtomicOdxType:
-        # Extract coded values
+        # Extract coded value
         coded_value = self.diag_coded_type.decode_from_pdu(decode_state)
 
         # Check if the coded value in the message is correct.
         if coded_value not in self.coded_values:
-            warnings.warn(
-                f"Coded constant parameter does not match! "
-                f"The parameter {self.short_name} expected a coded "
-                f"value in {str(self.coded_values)} but got {str(coded_value)} "
-                f"at byte position {decode_state.cursor_byte_position} "
-                f"in coded message {decode_state.coded_message.hex()}.",
-                DecodeError,
-                stacklevel=1,
-            )
+            raise DecodeMismatch(f"NRC-CONST parameter {self.short_name} does not apply")
 
         return coded_value
 

odxtools/parameters/systemparameter.py

@@ -26,7 +26,7 @@ class SystemParameter(ParameterWithDOP):
 
         kwargs = dataclass_fields_asdict(ParameterWithDOP.from_et(et_element, doc_frags))
 
-        sysparam = odxrequire(et_element.findtext("SYSPARAM"))
+        sysparam = odxrequire(et_element.get("SYSPARAM"))
 
         return SystemParameter(sysparam=sysparam, **kwargs)
 

odxtools/version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '7.2.0'
-__version_tuple__ = version_tuple = (7, 2, 0)
+__version__ = version = '7.3.0'
+__version_tuple__ = version_tuple = (7, 3, 0)

{odxtools-7.2.0.dist-info → odxtools-7.3.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: odxtools
-Version: 7.2.0
+Version: 7.3.0
 Summary: Utilities to work with the ODX standard for automotive diagnostics
 Author-email: Katrin Bauer <katrin.bauer@mbition.io>, Andreas Lauser <andreas.lauser@mbition.io>, Ayoub Kaanich <kayoub5@live.com>
 Maintainer-email: Andreas Lauser <andreas.lauser@mbition.io>, Ayoub Kaanich <kayoub5@live.com>