odxtools 8.3.4__py3-none-any.whl → 9.0.0__py3-none-any.whl

odxtools/dtcdop.py

@@ -15,13 +15,59 @@ from .dopbase import DopBase
 from .encodestate import EncodeState
 from .exceptions import DecodeError, EncodeError, odxassert, odxraise, odxrequire
 from .nameditemlist import NamedItemList
-from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef
+from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef, resolve_snref
 from .odxtypes import ParameterValue, odxstr_to_bool
 from .physicaltype import PhysicalType
 from .snrefcontext import SnRefContext
 from .utils import dataclass_fields_asdict
 
 
+@dataclass
+class LinkedDtcDop:
+    not_inherited_dtc_snrefs: List[str]
+    dtc_dop_ref: OdxLinkRef
+
+    @property
+    def dtc_dop(self) -> "DtcDop":
+        return self._dtc_dop
+
+    @property
+    def short_name(self) -> str:
+        return self._dtc_dop.short_name
+
+    @property
+    def not_inherited_dtcs(self) -> NamedItemList[DiagnosticTroubleCode]:
+        return self._not_inherited_dtcs
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "LinkedDtcDop":
+        not_inherited_dtc_snrefs = [
+            odxrequire(el.get("SHORT-NAME"))
+            for el in et_element.iterfind("NOT-INHERITED-DTC-SNREFS/"
+                                          "NOT-INHERITED-DTC-SNREF")
+        ]
+
+        dtc_dop_ref = odxrequire(OdxLinkRef.from_et(et_element.find("DTC-DOP-REF"), doc_frags))
+
+        return LinkedDtcDop(
+            not_inherited_dtc_snrefs=not_inherited_dtc_snrefs, dtc_dop_ref=dtc_dop_ref)
+
+    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+        return {}
+
+    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
+        self._dtc_dop = odxlinks.resolve(self.dtc_dop_ref, DtcDop)
+
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
+        dtc_dop = self._dtc_dop
+        not_inherited_dtcs = [
+            resolve_snref(ni_snref, dtc_dop.dtcs, DiagnosticTroubleCode)
+            for ni_snref in self.not_inherited_dtc_snrefs
+        ]
+
+        self._not_inherited_dtcs = NamedItemList(not_inherited_dtcs)
+
+
 @dataclass
 class DtcDop(DopBase):
     """A DOP describing a diagnostic trouble code"""
@@ -30,9 +76,12 @@ class DtcDop(DopBase):
     physical_type: PhysicalType
     compu_method: CompuMethod
     dtcs_raw: List[Union[DiagnosticTroubleCode, OdxLinkRef]]
-    linked_dtc_dop_refs: List[OdxLinkRef]
+    linked_dtc_dops_raw: List[LinkedDtcDop]
     is_visible_raw: Optional[bool]
 
+    def __post_init__(self) -> None:
+        self._init_finished = False
+
     @staticmethod
     def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "DtcDop":
         """Reads a DTC-DOP."""
@@ -56,12 +105,10 @@ class DtcDop(DopBase):
                 elif dtc_proxy_elem.tag == "DTC-REF":
                     dtcs_raw.append(OdxLinkRef.from_et(dtc_proxy_elem, doc_frags))
 
-        # TODO: NOT-INHERITED-DTC-SNREFS
-        linked_dtc_dop_refs = [
-            OdxLinkRef.from_et(dtc_ref_elem, doc_frags)
+        linked_dtc_dops_raw = [
+            LinkedDtcDop.from_et(dtc_ref_elem, doc_frags)
             for dtc_ref_elem in et_element.iterfind("LINKED-DTC-DOPS/"
-                                                    "LINKED-DTC-DOP/"
-                                                    "DTC-DOP-REF")
+                                                    "LINKED-DTC-DOP")
         ]
         is_visible_raw = odxstr_to_bool(et_element.get("IS-VISIBLE"))
 
@@ -70,7 +117,7 @@ class DtcDop(DopBase):
             physical_type=physical_type,
             compu_method=compu_method,
             dtcs_raw=dtcs_raw,
-            linked_dtc_dop_refs=linked_dtc_dop_refs,
+            linked_dtc_dops_raw=linked_dtc_dops_raw,
             is_visible_raw=is_visible_raw,
             **kwargs)
 
@@ -79,12 +126,12 @@ class DtcDop(DopBase):
         return self._dtcs
 
     @property
-    def is_visible(self) -> bool:
-        return self.is_visible_raw is True
+    def linked_dtc_dops(self) -> NamedItemList[LinkedDtcDop]:
+        return self._linked_dtc_dops
 
     @property
-    def linked_dtc_dops(self) -> NamedItemList["DtcDop"]:
-        return self._linked_dtc_dops
+    def is_visible(self) -> bool:
+        return self.is_visible_raw is True
 
     @override
     def decode_from_pdu(self, decode_state: DecodeState) -> ParameterValue:
@@ -185,6 +232,9 @@ class DtcDop(DopBase):
             if isinstance(dtc_proxy, DiagnosticTroubleCode):
                 odxlinks.update(dtc_proxy._build_odxlinks())
 
+        for linked_dtc_dop in self.linked_dtc_dops_raw:
+            odxlinks.update(linked_dtc_dop._build_odxlinks())
+
         return odxlinks
 
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
@@ -201,10 +251,19 @@ class DtcDop(DopBase):
                 dtc = odxlinks.resolve(dtc_proxy, DiagnosticTroubleCode)
                 self._dtcs.append(dtc)
 
-        linked_dtc_dops = [odxlinks.resolve(x, DtcDop) for x in self.linked_dtc_dop_refs]
-        self._linked_dtc_dops = NamedItemList(linked_dtc_dops)
+        for linked_dtc_dop in self.linked_dtc_dops_raw:
+            linked_dtc_dop._resolve_odxlinks(odxlinks)
 
     def _resolve_snrefs(self, context: SnRefContext) -> None:
+        # hack to avoid initializing the DtcDop object multiple
+        # times. This is required, because the linked DTC DOP feature
+        # requires the "parent" DTC DOPs to be fully initialized but
+        # the standard does not define a formal ordering of DTC DOPs.
+        if self._init_finished:
+            return
+
+        self._init_finished = True
+
         super()._resolve_snrefs(context)
 
         self.compu_method._resolve_snrefs(context)
@@ -212,3 +271,31 @@ class DtcDop(DopBase):
         for dtc_proxy in self.dtcs_raw:
             if isinstance(dtc_proxy, DiagnosticTroubleCode):
                 dtc_proxy._resolve_snrefs(context)
+
+        for linked_dtc_dop in self.linked_dtc_dops_raw:
+            linked_dtc_dop._resolve_snrefs(context)
+
+        # add the inherited DTCs from linked DTC DOPs. Note that this
+        # requires that there are no cycles in the "link-hierarchy"
+        dtc_short_names = {dtc.short_name for dtc in self._dtcs}
+        for linked_dtc_dop in self.linked_dtc_dops_raw:
+            linked_dtc_dop.dtc_dop._resolve_snrefs(context)
+
+            for dtc in linked_dtc_dop.dtc_dop.dtcs:
+                if dtc.short_name in dtc_short_names:
+                    # we already have a DTC with that name. Since we
+                    # are not supposed to overwrite the local DTCs, we
+                    # skip processing this one. TODO: Are inheritance
+                    # conflicts for DTCs allowed?
+                    continue
+
+                if dtc.short_name in linked_dtc_dop.not_inherited_dtc_snrefs:
+                    # DTC is explicitly not inherited
+                    continue
+
+                self._dtcs.append(dtc)
+                dtc_short_names.add(dtc.short_name)
+
+        # at this place, the linked DTC DOPs exhibit .short_name, so
+        # we can create a NamedItemList...
+        self._linked_dtc_dops = NamedItemList(self.linked_dtc_dops_raw)

odxtools/inputparam.py

@@ -3,8 +3,6 @@ from dataclasses import dataclass
 from typing import Any, Dict, List, Optional
 from xml.etree import ElementTree
 
-from deprecation import deprecated
-
 from .dopbase import DopBase
 from .element import NamedElement
 from .exceptions import odxrequire
@@ -49,8 +47,3 @@ class InputParam(NamedElement):
     def dop_base(self) -> DopBase:
         """The data object property describing this parameter."""
         return self._dop_base
-
-    @property
-    @deprecated(details="use .dop_base")  # type: ignore[misc]
-    def dop(self) -> DopBase:
-        return self._dop_base

odxtools/leadinglengthinfotype.py

@@ -1,6 +1,6 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import List, Optional
+from typing import List
 from xml.etree import ElementTree
 
 from typing_extensions import override
@@ -50,13 +50,6 @@ class LeadingLengthInfoType(DiagCodedType):
     def dct_type(self) -> DctType:
         return "LEADING-LENGTH-INFO-TYPE"
 
-    def get_static_bit_length(self) -> Optional[int]:
-        # note that self.bit_length is just the length of the length
-        # specifier field. This is then followed by the same number of
-        # bytes as the value of this field, i.e., the length of this
-        # DCT is dynamic!
-        return None
-
     @override
     def encode_into_pdu(self, internal_value: AtomicOdxType, encode_state: EncodeState) -> None:
 

odxtools/message.py

@@ -2,8 +2,6 @@
 from dataclasses import dataclass
 from typing import TYPE_CHECKING, Union
 
-from deprecation import deprecated
-
 from .odxtypes import ParameterValue, ParameterValueDict
 
 if TYPE_CHECKING:
@@ -29,8 +27,3 @@ class Message:
 
     def __getitem__(self, key: str) -> ParameterValue:
         return self.param_dict[key]
-
-    @property
-    @deprecated("use .coding_object")  # type: ignore[misc]
-    def structure(self) -> Union["Request", "Response"]:
-        return self.coding_object

odxtools/minmaxlengthtype.py

@@ -20,6 +20,10 @@ class MinMaxLengthType(DiagCodedType):
     max_length: Optional[int]
     termination: str
 
+    @property
+    def dct_type(self) -> DctType:
+        return "MIN-MAX-LENGTH-TYPE"
+
     @staticmethod
     @override
     def from_et(et_element: ElementTree.Element,
@@ -50,10 +54,6 @@ class MinMaxLengthType(DiagCodedType):
             "END-OF-PDU",
         ], f"A min-max length type cannot have the termination {self.termination}")
 
-    @property
-    def dct_type(self) -> DctType:
-        return "MIN-MAX-LENGTH-TYPE"
-
     def __termination_sequence(self) -> bytes:
         """Returns the termination byte sequence if it isn't defined."""
         # The termination sequence is actually not specified by ASAM

odxtools/outputparam.py

@@ -3,8 +3,6 @@ from dataclasses import dataclass
 from typing import Any, Dict, List, Optional
 from xml.etree import ElementTree
 
-from deprecation import deprecated
-
 from .dopbase import DopBase
 from .element import IdentifiableElement
 from .exceptions import odxrequire
@@ -40,8 +38,3 @@ class OutputParam(IdentifiableElement):
     def dop_base(self) -> DopBase:
         """The data object property describing this parameter."""
         return self._dop_base
-
-    @property
-    @deprecated(details="use .dop_base")  # type: ignore[misc]
-    def dop(self) -> DopBase:
-        return self._dop_base

odxtools/parameterinfo.py

@@ -34,36 +34,36 @@ from .staticfield import StaticField
 
 def _get_linear_segment_info(segment: LinearSegment) -> str:
     ll = segment.physical_lower_limit
-    ul = segment.physical_upper_limit
     if ll is None or ll.interval_type == IntervalType.INFINITE:
         ll_str = "(-inf"
     else:
         ll_delim = '(' if ll.interval_type == IntervalType.OPEN else '['
         ll_str = f"{ll_delim}{ll._value!r}"
 
-        if ul is None or ul.interval_type == IntervalType.INFINITE:
-            ul_str = "inf)"
-        else:
-            ul_delim = ')' if ul.interval_type == IntervalType.OPEN else ']'
-            ul_str = f"{ul._value!r}{ul_delim}"
+    ul = segment.physical_upper_limit
+    if ul is None or ul.interval_type == IntervalType.INFINITE:
+        ul_str = "inf)"
+    else:
+        ul_delim = ')' if ul.interval_type == IntervalType.OPEN else ']'
+        ul_str = f"{ul._value!r}{ul_delim}"
 
     return f"{ll_str}, {ul_str}"
 
 
 def _get_rat_func_segment_info(segment: RatFuncSegment) -> str:
     ll = segment.lower_limit
-    ul = segment.upper_limit
     if ll is None or ll.interval_type == IntervalType.INFINITE:
         ll_str = "(-inf"
     else:
         ll_delim = '(' if ll.interval_type == IntervalType.OPEN else '['
         ll_str = f"{ll_delim}{ll._value!r}"
 
-        if ul is None or ul.interval_type == IntervalType.INFINITE:
-            ul_str = "inf)"
-        else:
-            ul_delim = ')' if ul.interval_type == IntervalType.OPEN else ']'
-            ul_str = f"{ul._value!r}{ul_delim}"
+    ul = segment.upper_limit
+    if ul is None or ul.interval_type == IntervalType.INFINITE:
+        ul_str = "inf)"
+    else:
+        ul_delim = ')' if ul.interval_type == IntervalType.OPEN else ']'
+        ul_str = f"{ul._value!r}{ul_delim}"
 
     return f"{ll_str}, {ul_str}"
 

odxtools/parameters/parameter.py

@@ -33,11 +33,13 @@ ParameterType = Literal[
 @dataclass
 class Parameter(NamedElement):
     """This class corresponds to POSITIONABLE-PARAM in the ODX
-    specification.
+    specification
 
-    Be aware that, even though the ODX specification seems to make the
-    distinction of "positionable" and "normal" parameters, it does not
-    define any non-positionable parameter types.
+    All parameter classes must adhere to the `Codec` type protocol, so
+    `isinstance(param, Codec)` ought to be true.  Be aware that, even
+    though the ODX specification seems to make the distinction of
+    "positionable" and "normal" parameters, it does not define any
+    non-positionable parameter types.
 
     """
     oid: Optional[str]

odxtools/paramlengthinfotype.py

@@ -20,9 +20,16 @@ if TYPE_CHECKING:
 
 @dataclass
 class ParamLengthInfoType(DiagCodedType):
-
     length_key_ref: OdxLinkRef
 
+    @property
+    def dct_type(self) -> DctType:
+        return "PARAM-LENGTH-INFO-TYPE"
+
+    @property
+    def length_key(self) -> "LengthKeyParameter":
+        return self._length_key
+
     @staticmethod
     @override
     def from_et(et_element: ElementTree.Element,
@@ -34,10 +41,6 @@ class ParamLengthInfoType(DiagCodedType):
 
         return ParamLengthInfoType(length_key_ref=length_key_ref, **kwargs)
 
-    @property
-    def dct_type(self) -> DctType:
-        return "PARAM-LENGTH-INFO-TYPE"
-
     def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
         return super()._build_odxlinks()
 
@@ -54,10 +57,6 @@ class ParamLengthInfoType(DiagCodedType):
         """Recursively resolve any short-name references"""
         super()._resolve_snrefs(context)
 
-    @property
-    def length_key(self) -> "LengthKeyParameter":
-        return self._length_key
-
     @override
     def encode_into_pdu(self, internal_value: AtomicOdxType, encode_state: EncodeState) -> None:
         bit_length = encode_state.length_keys.get(self.length_key.short_name)

odxtools/request.py

@@ -1,39 +1,132 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import List
+from typing import Any, Dict, List, Optional, cast
 from xml.etree import ElementTree
 
-from .basicstructure import BasicStructure
+from .admindata import AdminData
+from .codec import (composite_codec_decode_from_pdu, composite_codec_encode_into_pdu,
+                    composite_codec_get_coded_const_prefix, composite_codec_get_free_parameters,
+                    composite_codec_get_required_parameters, composite_codec_get_static_bit_length)
+from .decodestate import DecodeState
+from .element import IdentifiableElement
 from .encodestate import EncodeState
-from .odxlink import OdxDocFragment
-from .odxtypes import ParameterValue
+from .exceptions import odxraise
+from .nameditemlist import NamedItemList
+from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
+from .odxtypes import ParameterValue, ParameterValueDict
+from .parameters.createanyparameter import create_any_parameter_from_et
+from .parameters.parameter import Parameter
 from .snrefcontext import SnRefContext
+from .specialdatagroup import SpecialDataGroup
 from .utils import dataclass_fields_asdict
 
 
-# TODO: The spec does not say that requests are basic structures. For
-# now, we derive from it anyway because it simplifies the en- and
-# decoding machinery...
 @dataclass
-class Request(BasicStructure):
+class Request(IdentifiableElement):
+    """Represents all information related to an UDS request
+
+    This class implements the `CompositeCodec` interface.
+    """
+    admin_data: Optional[AdminData]
+    parameters: NamedItemList[Parameter]
+    sdgs: List[SpecialDataGroup]
+
+    @property
+    def required_parameters(self) -> List[Parameter]:
+        return composite_codec_get_required_parameters(self)
+
+    @property
+    def free_parameters(self) -> List[Parameter]:
+        return composite_codec_get_free_parameters(self)
 
     @staticmethod
     def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "Request":
-        """Reads a response."""
-        kwargs = dataclass_fields_asdict(BasicStructure.from_et(et_element, doc_frags))
+        kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, doc_frags))
 
-        return Request(**kwargs)
+        admin_data = AdminData.from_et(et_element.find("ADMIN-DATA"), doc_frags)
+        parameters = NamedItemList([
+            create_any_parameter_from_et(et_parameter, doc_frags)
+            for et_parameter in et_element.iterfind("PARAMS/PARAM")
+        ])
+        sdgs = [
+            SpecialDataGroup.from_et(sdge, doc_frags) for sdge in et_element.iterfind("SDGS/SDG")
+        ]
 
-    def encode(self, **kwargs: ParameterValue) -> bytes:
-        encode_state = EncodeState(is_end_of_pdu=True)
+        return Request(admin_data=admin_data, parameters=parameters, sdgs=sdgs, **kwargs)
 
-        self.encode_into_pdu(physical_value=kwargs, encode_state=encode_state)
+    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+        result = {self.odx_id: self}
 
-        return encode_state.coded_message
+        if self.admin_data is not None:
+            result.update(self.admin_data._build_odxlinks())
+
+        for param in self.parameters:
+            result.update(param._build_odxlinks())
+
+        for sdg in self.sdgs:
+            result.update(sdg._build_odxlinks())
+
+        return result
+
+    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
+        if self.admin_data is not None:
+            self.admin_data._resolve_odxlinks(odxlinks)
+
+        for param in self.parameters:
+            param._resolve_odxlinks(odxlinks)
+
+        for sdg in self.sdgs:
+            sdg._resolve_odxlinks(odxlinks)
 
     def _resolve_snrefs(self, context: SnRefContext) -> None:
         context.request = self
+        context.parameters = self.parameters
 
-        super()._resolve_snrefs(context)
+        if self.admin_data is not None:
+            self.admin_data._resolve_snrefs(context)
+
+        for param in self.parameters:
+            param._resolve_snrefs(context)
+
+        for sdg in self.sdgs:
+            sdg._resolve_snrefs(context)
 
         context.request = None
+        context.parameters = None
+
+    def get_static_bit_length(self) -> Optional[int]:
+        return composite_codec_get_static_bit_length(self)
+
+    def print_free_parameters_info(self) -> None:
+        """Print a human readable description of the composite codec's
+        free parameters to `stdout`
+        """
+        from .parameterinfo import parameter_info
+
+        print(parameter_info(self.free_parameters), end="")
+
+    def encode(self, **kwargs: ParameterValue) -> bytearray:
+        encode_state = EncodeState(is_end_of_pdu=True)
+
+        self.encode_into_pdu(physical_value=kwargs, encode_state=encode_state)
+
+        return encode_state.coded_message
+
+    def decode(self, message: bytes) -> ParameterValueDict:
+        decode_state = DecodeState(coded_message=message)
+        param_values = self.decode_from_pdu(decode_state)
+
+        if not isinstance(param_values, dict):
+            odxraise("Decoding a request must result in a dictionary")
+
+        return cast(ParameterValueDict, param_values)
+
+    def encode_into_pdu(self, physical_value: Optional[ParameterValue],
+                        encode_state: EncodeState) -> None:
+        composite_codec_encode_into_pdu(self, physical_value, encode_state)
+
+    def decode_from_pdu(self, decode_state: DecodeState) -> ParameterValue:
+        return composite_codec_decode_from_pdu(self, decode_state)
+
+    def coded_const_prefix(self, request_prefix: bytes = b'') -> bytes:
+        return composite_codec_get_coded_const_prefix(self, request_prefix)