odxtools 6.6.1__py3-none-any.whl → 6.7.0__py3-none-any.whl

odxtools/dataobjectproperty.py

@@ -59,20 +59,20 @@ class DataObjectProperty(DopBase):
         compu_method = create_any_compu_method_from_et(
             odxrequire(et_element.find("COMPU-METHOD")),
             doc_frags,
-            diag_coded_type.base_data_type,
-            physical_type.base_data_type,
+            internal_type=diag_coded_type.base_data_type,
+            physical_type=physical_type.base_data_type,
         )
         unit_ref = OdxLinkRef.from_et(et_element.find("UNIT-REF"), doc_frags)
 
         internal_constr = None
         if (internal_constr_elem := et_element.find("INTERNAL-CONSTR")) is not None:
-            internal_constr = InternalConstr.from_et(
-                internal_constr_elem, internal_type=diag_coded_type.base_data_type)
+            internal_constr = InternalConstr.constr_from_et(
+                internal_constr_elem, doc_frags, value_type=diag_coded_type.base_data_type)
 
         physical_constr = None
         if (physical_constr_elem := et_element.find("PHYS-CONSTR")) is not None:
-            physical_constr = InternalConstr.from_et(
-                physical_constr_elem, internal_type=physical_type.base_data_type)
+            physical_constr = InternalConstr.constr_from_et(
+                physical_constr_elem, doc_frags, value_type=physical_type.base_data_type)
 
         return DataObjectProperty(
             diag_coded_type=diag_coded_type,
@@ -120,14 +120,17 @@ class DataObjectProperty(DopBase):
 
         return self.compu_method.convert_physical_to_internal(physical_value)
 
-    def convert_physical_to_bytes(self, physical_value: Any, encode_state: EncodeState,
-                                  bit_position: int) -> bytes:
+    def convert_physical_to_bytes(self,
+                                  physical_value: Any,
+                                  encode_state: EncodeState,
+                                  bit_position: int = 0) -> bytes:
         """
         Convert a physical representation of a parameter to a string bytes that can be send over the wire
         """
         if not self.is_valid_physical_value(physical_value):
-            raise EncodeError(f"The value {repr(physical_value)} of type {type(physical_value)}"
-                              f" is not a valid.")
+            raise EncodeError(
+                f"The value {repr(physical_value)} of type {type(physical_value).__name__}"
+                f" is not a valid.")
 
         internal_val = self.convert_physical_to_internal(physical_value)
         return self.diag_coded_type.convert_internal_to_bytes(

odxtools/decodestate.py

@@ -1,6 +1,6 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass, field
-from typing import TYPE_CHECKING, Dict
+from typing import TYPE_CHECKING, Dict, cast
 
 import odxtools.exceptions as exceptions
 
@@ -72,7 +72,7 @@ class DecodeState:
         """
         # If the bit length is zero, return "empty" values of each type
         if bit_length == 0:
-            return base_data_type.as_python_type()()
+            return base_data_type.python_type()
 
         byte_length = (bit_length + self.cursor_bit_position + 7) // 8
         if self.cursor_byte_position + byte_length > len(self.coded_message):
@@ -100,6 +100,7 @@ class DecodeState:
 
         text_errors = 'strict' if exceptions.strict_mode else 'replace'
         if base_data_type == DataType.A_ASCIISTRING:
+            assert isinstance(internal_value, (bytes, bytearray))
             # The spec says ASCII, meaning only byte values 0-127.
             # But in practice, vendors use iso-8859-1, aka latin-1
             # reason being iso-8859-1 never fails since it has a valid
@@ -107,9 +108,11 @@ class DecodeState:
             text_encoding = 'iso-8859-1'
             internal_value = internal_value.decode(encoding=text_encoding, errors=text_errors)
         elif base_data_type == DataType.A_UTF8STRING:
+            assert isinstance(internal_value, (bytes, bytearray))
             text_encoding = "utf-8"
             internal_value = internal_value.decode(encoding=text_encoding, errors=text_errors)
         elif base_data_type == DataType.A_UNICODE2STRING:
+            assert isinstance(internal_value, (bytes, bytearray))
             # For UTF-16, we need to manually decode the extracted
             # bytes to a string
             text_encoding = "utf-16-be" if is_highlow_byte_order else "utf-16-le"
@@ -118,4 +121,4 @@ class DecodeState:
         self.cursor_byte_position += byte_length
         self.cursor_bit_position = 0
 
-        return internal_value
+        return cast(AtomicOdxType, internal_value)

odxtools/determinenumberofitems.py

@@ -7,7 +7,7 @@ from .exceptions import odxrequire
 from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef
 
 if TYPE_CHECKING:
-    from ..diaglayer import DiagLayer
+    from .diaglayer import DiagLayer
 
 
 @dataclass

odxtools/diagcodedtype.py

@@ -1,7 +1,7 @@
 # SPDX-License-Identifier: MIT
 import abc
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Dict, Literal, Optional, Union
+from typing import TYPE_CHECKING, Any, Dict, Literal, Optional, Union, cast
 
 from .decodestate import ODX_TYPE_TO_FORMAT_LETTER, DecodeState
 from .encodestate import EncodeState
@@ -111,9 +111,9 @@ class DiagCodedType(abc.ABC):
 
         # If the bit length is zero, return empty bytes
         if bit_length == 0:
-            if (base_data_type in [
+            if (base_data_type.value in [
                     DataType.A_INT32, DataType.A_UINT32, DataType.A_FLOAT32, DataType.A_FLOAT64
-            ] and base_data_type != 0):
+            ] and base_data_type.value != 0):
                 raise EncodeError(
                     f"The number {repr(internal_value)} cannot be encoded into {bit_length} bits.")
             return b''
@@ -136,12 +136,13 @@ class DiagCodedType(abc.ABC):
         ]:
             coded = coded[::-1]
 
-        return coded
+        return cast(bytes, coded)
 
     def _minimal_byte_length_of(self, internal_value: Union[bytes, str]) -> int:
         """Helper method to get the minimal byte length.
         (needed for LeadingLength- and MinMaxLengthType)
         """
+        byte_length: int = -1
         # A_BYTEFIELD, A_ASCIISTRING, A_UNICODE2STRING, A_UTF8STRING
         if self.base_data_type == DataType.A_BYTEFIELD:
             byte_length = len(internal_value)

odxtools/diagdatadictionaryspec.py

@@ -4,6 +4,7 @@ from itertools import chain
 from typing import TYPE_CHECKING, Any, Dict, List, Optional
 from xml.etree import ElementTree
 
+from .admindata import AdminData
 from .basicstructure import BasicStructure
 from .createsdgs import create_sdgs_from_et
 from .dataobjectproperty import DataObjectProperty
@@ -14,11 +15,11 @@ from .endofpdufield import EndOfPduField
 from .environmentdata import EnvironmentData
 from .environmentdatadescription import EnvironmentDataDescription
 from .exceptions import odxraise
-from .globals import logger
 from .multiplexer import Multiplexer
 from .nameditemlist import NamedItemList
 from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
 from .specialdatagroup import SpecialDataGroup
+from .staticfield import StaticField
 from .structure import Structure
 from .table import Table
 from .unitspec import UnitSpec
@@ -29,35 +30,55 @@ if TYPE_CHECKING:
 
 @dataclass
 class DiagDataDictionarySpec:
+    admin_data: Optional[AdminData]
     dtc_dops: NamedItemList[DtcDop]
+    env_data_descs: NamedItemList[EnvironmentDataDescription]
     data_object_props: NamedItemList[DataObjectProperty]
     structures: NamedItemList[BasicStructure]
-    end_of_pdu_fields: NamedItemList[EndOfPduField]
+    static_fields: NamedItemList[StaticField]
     dynamic_length_fields: NamedItemList[DynamicLengthField]
-    tables: NamedItemList[Table]
-    env_data_descs: NamedItemList[EnvironmentDataDescription]
-    env_datas: NamedItemList[EnvironmentData]
+    #dynamic_endmarker_fields: NamedItemList[DynamicEndmarkerField]
+    end_of_pdu_fields: NamedItemList[EndOfPduField]
     muxs: NamedItemList[Multiplexer]
+    env_datas: NamedItemList[EnvironmentData]
     unit_spec: Optional[UnitSpec]
+    tables: NamedItemList[Table]
     sdgs: List[SpecialDataGroup]
 
     def __post_init__(self) -> None:
         self._all_data_object_properties: NamedItemList[DopBase] = NamedItemList(
             chain(
                 self.dtc_dops,
+                self.env_data_descs,
                 self.data_object_props,
                 self.structures,
-                self.end_of_pdu_fields,
+                self.static_fields,
                 self.dynamic_length_fields,
-                self.env_data_descs,
-                self.env_datas,
+                #self.dynamic_endmarker_fields,
+                self.end_of_pdu_fields,
                 self.muxs,
+                self.env_datas,
             ))
 
     @staticmethod
     def from_et(et_element: ElementTree.Element,
                 doc_frags: List[OdxDocFragment]) -> "DiagDataDictionarySpec":
-        # Parse DOP-BASEs
+        admin_data = None
+        if (admin_data_elem := et_element.find("ADMIN-DATA")) is not None:
+            admin_data = AdminData.from_et(admin_data_elem, doc_frags)
+
+        dtc_dops = []
+        for dtc_dop_elem in et_element.iterfind("DTC-DOPS/DTC-DOP"):
+            dtc_dop = DtcDop.from_et(dtc_dop_elem, doc_frags)
+            if not isinstance(dtc_dop, DtcDop):
+                odxraise()
+            dtc_dops.append(dtc_dop)
+
+        env_data_descs = [
+            EnvironmentDataDescription.from_et(env_data_desc_element, doc_frags)
+            for env_data_desc_element in et_element.iterfind("ENV-DATA-DESCS/ENV-DATA-DESC")
+        ]
+
         data_object_props = [
             DataObjectProperty.from_et(dop_element, doc_frags)
             for dop_element in et_element.iterfind("DATA-OBJECT-PROPS/DATA-OBJECT-PROP")
@@ -68,9 +89,9 @@ class DiagDataDictionarySpec:
             for structure_element in et_element.iterfind("STRUCTURES/STRUCTURE")
         ]
 
-        end_of_pdu_fields = [
-            EndOfPduField.from_et(eofp_element, doc_frags)
-            for eofp_element in et_element.iterfind("END-OF-PDU-FIELDS/END-OF-PDU-FIELD")
+        static_fields = [
+            StaticField.from_et(dl_element, doc_frags)
+            for dl_element in et_element.iterfind("STATIC-FIELDS/STATIC-FIELD")
         ]
 
         dynamic_length_fields = [
@@ -78,21 +99,20 @@ class DiagDataDictionarySpec:
             for dl_element in et_element.iterfind("DYNAMIC-LENGTH-FIELDS/DYNAMIC-LENGTH-FIELD")
         ]
 
-        dtc_dops = []
-        for dtc_dop_elem in et_element.iterfind("DTC-DOPS/DTC-DOP"):
-            dtc_dop = DtcDop.from_et(dtc_dop_elem, doc_frags)
-            if not isinstance(dtc_dop, DtcDop):
-                odxraise()
-            dtc_dops.append(dtc_dop)
+        # TODO: dynamic endmarker fields
+        #dynamic_endmarker_fields = [
+        #    DynamicEndmarkerField.from_et(dl_element, doc_frags)
+        #    for dl_element in et_element.iterfind("DYNAMIC-ENDMARKER-FIELDS/DYNAMIC-ENDMARKER-FIELD")
+        #]
 
-        tables = [
-            Table.from_et(table_element, doc_frags)
-            for table_element in et_element.iterfind("TABLES/TABLE")
+        end_of_pdu_fields = [
+            EndOfPduField.from_et(eofp_element, doc_frags)
+            for eofp_element in et_element.iterfind("END-OF-PDU-FIELDS/END-OF-PDU-FIELD")
         ]
 
-        env_data_descs = [
-            EnvironmentDataDescription.from_et(env_data_desc_element, doc_frags)
-            for env_data_desc_element in et_element.iterfind("ENV-DATA-DESCS/ENV-DATA-DESC")
+        muxs = [
+            Multiplexer.from_et(mux_element, doc_frags)
+            for mux_element in et_element.iterfind("MUXS/MUX")
         ]
 
         env_data_elements = chain(
@@ -105,42 +125,32 @@ class DiagDataDictionarySpec:
             for env_data_element in env_data_elements
         ]
 
-        muxs = [
-            Multiplexer.from_et(mux_element, doc_frags)
-            for mux_element in et_element.iterfind("MUXS/MUX")
-        ]
-
         if (spec_elem := et_element.find("UNIT-SPEC")) is not None:
             unit_spec = UnitSpec.from_et(spec_elem, doc_frags)
         else:
             unit_spec = None
 
-        # TODO: Parse different specs.. Which of them are needed?
-        for (path, name) in [
-            ("STATIC-FIELDS", "static fields"),
-            ("DYNAMIC-LENGTH-FIELDS/DYNAMIC-LENGTH-FIELD", "dynamic length fields"),
-            (
-                "DYNAMIC-ENDMARKER-FIELDS/DYNAMIC-ENDMARKER-FIELD",
-                "dynamic endmarker fields",
-            ),
-        ]:
-            num = len(list(et_element.iterfind(path)))
-            if num > 0:
-                logger.info(f"Not implemented: Did not parse {num} {name}.")
+        tables = [
+            Table.from_et(table_element, doc_frags)
+            for table_element in et_element.iterfind("TABLES/TABLE")
+        ]
 
         sdgs = create_sdgs_from_et(et_element.find("SDGS"), doc_frags)
 
         return DiagDataDictionarySpec(
+            admin_data=admin_data,
+            dtc_dops=NamedItemList(dtc_dops),
+            env_data_descs=NamedItemList(env_data_descs),
             data_object_props=NamedItemList(data_object_props),
             structures=NamedItemList(structures),
-            end_of_pdu_fields=NamedItemList(end_of_pdu_fields),
+            static_fields=NamedItemList(static_fields),
             dynamic_length_fields=NamedItemList(dynamic_length_fields),
-            dtc_dops=NamedItemList(dtc_dops),
+            #dynamic_endmarker_fields=NamedItemList(dynamic_endmarker_fields),
+            end_of_pdu_fields=NamedItemList(end_of_pdu_fields),
+            muxs=NamedItemList(muxs),
+            env_datas=NamedItemList(env_datas),
             unit_spec=unit_spec,
             tables=NamedItemList(tables),
-            env_data_descs=NamedItemList(env_data_descs),
-            env_datas=NamedItemList(env_datas),
-            muxs=NamedItemList(muxs),
             sdgs=sdgs,
         )
 
@@ -148,81 +158,96 @@ class DiagDataDictionarySpec:
         # note that DataDictionarySpec objects do not exhibit an ODXLINK id.
         odxlinks = {}
 
-        for data_object_prop in self.data_object_props:
-            odxlinks.update(data_object_prop._build_odxlinks())
+        if self.admin_data is not None:
+            odxlinks.update(self.admin_data._build_odxlinks())
         for dtc_dop in self.dtc_dops:
             odxlinks.update(dtc_dop._build_odxlinks())
         for env_data_desc in self.env_data_descs:
             odxlinks.update(env_data_desc._build_odxlinks())
-        for env_data in self.env_datas:
-            odxlinks.update(env_data._build_odxlinks())
-        for mux in self.muxs:
-            odxlinks.update(mux._build_odxlinks())
-        for sdg in self.sdgs:
-            odxlinks.update(sdg._build_odxlinks())
+        for data_object_prop in self.data_object_props:
+            odxlinks.update(data_object_prop._build_odxlinks())
         for structure in self.structures:
             odxlinks.update(structure._build_odxlinks())
+        for static_field in self.static_fields:
+            odxlinks.update(static_field._build_odxlinks())
         for dynamic_length_field in self.dynamic_length_fields:
             odxlinks.update(dynamic_length_field._build_odxlinks())
+        #for dynamic_endmarker_field in self.dynamic_endmarker_fields:
+        #    odxlinks.update(dynamic_endmarker_field._build_odxlinks())
         for end_of_pdu_field in self.end_of_pdu_fields:
             odxlinks.update(end_of_pdu_field._build_odxlinks())
-        for table in self.tables:
-            odxlinks.update(table._build_odxlinks())
-
+        for mux in self.muxs:
+            odxlinks.update(mux._build_odxlinks())
+        for env_data in self.env_datas:
+            odxlinks.update(env_data._build_odxlinks())
         if self.unit_spec is not None:
             odxlinks.update(self.unit_spec._build_odxlinks())
+        for table in self.tables:
+            odxlinks.update(table._build_odxlinks())
+        for sdg in self.sdgs:
+            odxlinks.update(sdg._build_odxlinks())
 
         return odxlinks
 
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
-        for data_object_prop in self.data_object_props:
-            data_object_prop._resolve_odxlinks(odxlinks)
+        if self.admin_data is not None:
+            self.admin_data._resolve_odxlinks(odxlinks)
         for dtc_dop in self.dtc_dops:
             dtc_dop._resolve_odxlinks(odxlinks)
+        for env_data_desc in self.env_data_descs:
+            env_data_desc._resolve_odxlinks(odxlinks)
+        for data_object_prop in self.data_object_props:
+            data_object_prop._resolve_odxlinks(odxlinks)
+        for structure in self.structures:
+            structure._resolve_odxlinks(odxlinks)
+        for static_field in self.static_fields:
+            static_field._resolve_odxlinks(odxlinks)
         for dynamic_length_field in self.dynamic_length_fields:
             dynamic_length_field._resolve_odxlinks(odxlinks)
+        #for dynamic_endmarker_field in self.dynamic_endmarker_fields:
+        #    dynamic_endmarker_field._resolve_odxlinks(odxlinks)
         for end_of_pdu_field in self.end_of_pdu_fields:
             end_of_pdu_field._resolve_odxlinks(odxlinks)
-        for env_data_desc in self.env_data_descs:
-            env_data_desc._resolve_odxlinks(odxlinks)
-        for env_data in self.env_datas:
-            env_data._resolve_odxlinks(odxlinks)
         for mux in self.muxs:
             mux._resolve_odxlinks(odxlinks)
-        for sdg in self.sdgs:
-            sdg._resolve_odxlinks(odxlinks)
-        for structure in self.structures:
-            structure._resolve_odxlinks(odxlinks)
-        for table in self.tables:
-            table._resolve_odxlinks(odxlinks)
-
+        for env_data in self.env_datas:
+            env_data._resolve_odxlinks(odxlinks)
         if self.unit_spec is not None:
             self.unit_spec._resolve_odxlinks(odxlinks)
+        for table in self.tables:
+            table._resolve_odxlinks(odxlinks)
+        for sdg in self.sdgs:
+            sdg._resolve_odxlinks(odxlinks)
 
     def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
-        for data_object_prop in self.data_object_props:
-            data_object_prop._resolve_snrefs(diag_layer)
+        if self.admin_data is not None:
+            self.admin_data._resolve_snrefs(diag_layer)
         for dtc_dop in self.dtc_dops:
             dtc_dop._resolve_snrefs(diag_layer)
+        for env_data_desc in self.env_data_descs:
+            env_data_desc._resolve_snrefs(diag_layer)
+        for data_object_prop in self.data_object_props:
+            data_object_prop._resolve_snrefs(diag_layer)
+        for structure in self.structures:
+            structure._resolve_snrefs(diag_layer)
+        for static_field in self.static_fields:
+            static_field._resolve_snrefs(diag_layer)
         for dynamic_length_field in self.dynamic_length_fields:
             dynamic_length_field._resolve_snrefs(diag_layer)
+        #for dynamic_endmarker_field in self.dynamic_endmarker_fields:
+        #    dynamic_endmarker_field._resolve_snrefs(diag_layer)
         for end_of_pdu_field in self.end_of_pdu_fields:
             end_of_pdu_field._resolve_snrefs(diag_layer)
-        for env_data_desc in self.env_data_descs:
-            env_data_desc._resolve_snrefs(diag_layer)
-        for env_data in self.env_datas:
-            env_data._resolve_snrefs(diag_layer)
         for mux in self.muxs:
             mux._resolve_snrefs(diag_layer)
-        for sdg in self.sdgs:
-            sdg._resolve_snrefs(diag_layer)
-        for structure in self.structures:
-            structure._resolve_snrefs(diag_layer)
-        for table in self.tables:
-            table._resolve_snrefs(diag_layer)
-
+        for env_data in self.env_datas:
+            env_data._resolve_snrefs(diag_layer)
         if self.unit_spec is not None:
             self.unit_spec._resolve_snrefs(diag_layer)
+        for table in self.tables:
+            table._resolve_snrefs(diag_layer)
+        for sdg in self.sdgs:
+            sdg._resolve_snrefs(diag_layer)
 
     @property
     def all_data_object_properties(self) -> NamedItemList[DopBase]:

odxtools/diaglayer.py

@@ -20,7 +20,7 @@ from .diaglayerraw import DiagLayerRaw
 from .diaglayertype import DiagLayerType
 from .diagservice import DiagService
 from .ecuvariantpattern import EcuVariantPattern
-from .exceptions import DecodeError, OdxWarning, odxassert
+from .exceptions import DecodeError, OdxWarning, odxassert, odxraise
 from .functionalclass import FunctionalClass
 from .message import Message
 from .nameditemlist import NamedItemList, OdxNamed
@@ -37,7 +37,6 @@ from .table import Table
 from .unitgroup import UnitGroup
 from .unitspec import UnitSpec
 
-T = TypeVar("T")
 TNamed = TypeVar("TNamed", bound=OdxNamed)
 
 PrefixTree = Dict[int, Union[List[DiagService], "PrefixTree"]]
@@ -54,6 +53,9 @@ class DiagLayer:
 
     diag_layer_raw: DiagLayerRaw
 
+    def __post_init__(self) -> None:
+        self._global_negative_responses: NamedItemList[Response]
+
     @staticmethod
     def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "DiagLayer":
         diag_layer_raw = DiagLayerRaw.from_et(et_element, doc_frags)
@@ -193,9 +195,11 @@ class DiagLayer:
         # inherited objects. To me, this seems rather inelegant, but
         # hey, it's described like this in the standard.
         self._diag_data_dictionary_spec = DiagDataDictionarySpec(
+            admin_data=None,
             data_object_props=dops,
             dtc_dops=dtc_dops,
             structures=structures,
+            static_fields=NamedItemList(),
             end_of_pdu_fields=end_of_pdu_fields,
             dynamic_length_fields=dynamic_length_fields,
             tables=tables,
@@ -350,7 +354,7 @@ class DiagLayer:
         return self._global_negative_responses
 
     @property
-    @deprecated(details="use diag_data_dictionary_spec.tables")
+    @deprecated(details="use diag_data_dictionary_spec.tables")  # type: ignore[misc]
     def tables(self) -> NamedItemList[Table]:
         return self.diag_data_dictionary_spec.tables
 
@@ -389,9 +393,9 @@ class DiagLayer:
 
     def _compute_available_objects(
         self,
-        get_local_objects: Callable[["DiagLayer"], Iterable[T]],
+        get_local_objects: Callable[["DiagLayer"], Iterable[TNamed]],
         get_not_inherited: Callable[[ParentRef], Iterable[str]],
-    ) -> Iterable[T]:
+    ) -> Iterable[TNamed]:
         """Helper method to compute the set of all objects applicable
         to the DiagLayer if these objects are subject to the value
         inheritance mechanism
@@ -410,31 +414,72 @@ class DiagLayer:
 
         """
 
-        result_dict: Dict[str, T] = {}
+        local_objects = get_local_objects(self)
+        local_object_short_names = {x.short_name for x in local_objects}
+        result_dict: Dict[str, Tuple[TNamed, DiagLayer]] = {}
 
         # populate the result dictionary with the inherited objects
-        #
-        # TODO (?): make sure that there are no "illegal" collisions
-        # i.e., different objects with the same short name stemming
-        # from parent layers exhibiting the same priority that are not
-        # overwritten by a locally defined object. (IMO, this is quite
-        # a corner case.)
-        for parent_ref in self._get_parent_refs_sorted_by_priority():
+        for parent_ref in self._get_parent_refs_sorted_by_priority(reverse=True):
             parent_dl = parent_ref.layer
-            for dc in parent_dl._compute_available_objects(get_local_objects, get_not_inherited):
-                result_dict[dc.short_name] = dc  # type: ignore[attr-defined]
 
-            # remove the explictly not inherited objects
-            for sn in get_not_inherited(parent_ref):
-                if sn in result_dict:
-                    del result_dict[sn]
+            # retrieve the set of short names of the objects which we
+            # are not supposed to inherit
+            not_inherited_short_names = set(get_not_inherited(parent_ref))
 
-        # consider the locally defined objects (override the
-        # inherited entries or add new ones)
-        for obj in get_local_objects(self):
-            result_dict[obj.short_name] = obj  # type: ignore[attr-defined]
+            # compute the list of objects which we are supposed to
+            # inherit from this diagnostic layer
+            inherited_objects = [
+                x
+                for x in parent_dl._compute_available_objects(get_local_objects, get_not_inherited)
+                if x.short_name not in not_inherited_short_names
+            ]
 
-        return result_dict.values()
+            # update the result set with the objects from the current parent_ref
+            for obj in inherited_objects:
+
+                # no object with the given short name currently
+                # exits. add it to the result set and continue
+                if obj.short_name not in result_dict:
+                    result_dict[obj.short_name] = (obj, parent_dl)
+                    continue
+
+                # if an object with a given name already exists,
+                # there's no problem if it was inherited from a parent
+                # of different priority than the one currently
+                # considered
+                orig_prio = result_dict[obj.short_name][1].variant_type.inheritance_priority
+                new_prio = parent_dl.variant_type.inheritance_priority
+                if new_prio < orig_prio:
+                    continue
+                elif orig_prio < new_prio:
+                    result_dict[obj.short_name] = (obj, parent_dl)
+                    continue
+
+                # if there is a conflict on the same priority level,
+                # it does not matter if the object is overridden
+                # locally anyway...
+                if obj.short_name in local_object_short_names:
+                    continue
+
+                # if all of these conditions do not apply, and if the
+                # inherited objects are identical, there is no
+                # conflict. (note that value comparisons of complete
+                # complex objects tend to be expensive, so this test
+                # is done last.)
+                if obj == result_dict[obj.short_name][0]:
+                    continue
+
+                odxraise(f"Diagnostic layer {self.short_name} cannot inherit object "
+                         f"{obj.short_name} due to an unresolveable inheritance conflict between "
+                         f"parent layers {result_dict[obj.short_name][1].short_name} "
+                         f"and {parent_dl.short_name}")
+
+        # add the locally defined entries, overriding the inherited
+        # ones if necessary
+        for obj in local_objects:
+            result_dict[obj.short_name] = (obj, self)
+
+        return [x[0] for x in result_dict.values()]
 
     def _get_local_diag_comms(self, odxlinks: OdxLinkDatabase) -> Iterable[DiagComm]:
         """Return the list of locally defined diagnostic communications.
@@ -767,7 +812,7 @@ class DiagLayer:
 
         return int(result)
 
-    @deprecated(details="use get_can_receive_id()")
+    @deprecated(details="use get_can_receive_id()")  # type: ignore[misc]
     def get_receive_id(self) -> Optional[int]:
         return self.get_can_receive_id()
 
@@ -796,7 +841,7 @@ class DiagLayer:
 
         return int(result)
 
-    @deprecated(details="use get_can_send_id()")
+    @deprecated(details="use get_can_send_id()")  # type: ignore[misc]
     def get_send_id(self) -> Optional[int]:
         return self.get_can_send_id()
 
@@ -1097,7 +1142,8 @@ class DiagLayer:
 
         if len(decoded_messages) == 0:
             raise DecodeError(
-                f"None of the services {candidate_services} could parse {message.hex()}.")
+                f"None of the services {[x.short_name for x in candidate_services]} could parse {message.hex()}."
+            )
 
         return decoded_messages
 
@@ -1106,14 +1152,8 @@ class DiagLayer:
 
         return self._decode(message, candidate_services)
 
-    def decode_response(self, response: bytes, request: Union[bytes, Message]) -> List[Message]:
-        if isinstance(request, Message):
-            candidate_services = [request.service]
-        else:
-            if not isinstance(request, (bytes, bytearray)):
-                raise TypeError(f"Request parameter must have type "
-                                f"Message, bytes or bytearray but was {type(request)}")
-            candidate_services = self._find_services_for_uds(request)
+    def decode_response(self, response: bytes, request: bytes) -> List[Message]:
+        candidate_services = self._find_services_for_uds(request)
         if candidate_services is None:
             raise DecodeError(f"Couldn't find corresponding service for request {request.hex()}.")