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

odxtools/parameters/createanyparameter.py

@@ -2,13 +2,9 @@
 from typing import List
 from xml.etree import ElementTree
 
-from ..createanydiagcodedtype import create_any_diag_coded_type_from_et
-from ..createsdgs import create_sdgs_from_et
-from ..element import NamedElement
-from ..exceptions import odxrequire
+from ..exceptions import odxraise
 from ..globals import xsi
-from ..odxlink import OdxDocFragment, OdxLinkId, OdxLinkRef
-from ..utils import dataclass_fields_asdict
+from ..odxlink import OdxDocFragment
 from .codedconstparameter import CodedConstParameter
 from .dynamicparameter import DynamicParameter
 from .lengthkeyparameter import LengthKeyParameter
@@ -27,203 +23,33 @@ from .valueparameter import ValueParameter
 def create_any_parameter_from_et(et_element: ElementTree.Element,
                                  doc_frags: List[OdxDocFragment]) \
                                  -> Parameter:
-    kwargs = dataclass_fields_asdict(NamedElement.from_et(et_element, doc_frags))
-    semantic = et_element.get("SEMANTIC")
-    byte_position_str = et_element.findtext("BYTE-POSITION")
-    byte_position = int(byte_position_str) if byte_position_str is not None else None
-    bit_position_str = et_element.findtext("BIT-POSITION")
-    bit_position = None
-    if bit_position_str is not None:
-        bit_position = int(bit_position_str)
     parameter_type = et_element.get(f"{xsi}type")
 
-    sdgs = create_sdgs_from_et(et_element.find("SDGS"), doc_frags)
-
     # Which attributes are set depends on the type of the parameter.
-    if parameter_type in ["VALUE", "PHYS-CONST", "SYSTEM", "LENGTH-KEY"]:
-        dop_ref = OdxLinkRef.from_et(et_element.find("DOP-REF"), doc_frags)
-        dop_snref = None
-        if (dop_snref_elem := et_element.find("DOP-SNREF")) is not None:
-            dop_snref = odxrequire(dop_snref_elem.get("SHORT-NAME"))
-
-        if dop_ref is None and dop_snref is None:
-            raise ValueError(
-                f"A parameter of type {parameter_type} must reference a DOP! {dop_ref}, {dop_snref}"
-            )
-
     if parameter_type == "VALUE":
-        physical_default_value_raw = (
-            et_element.findtext("PHYSICAL-DEFAULT-VALUE")
-            if et_element.find("PHYSICAL-DEFAULT-VALUE") is not None else None)
-
-        return ValueParameter(
-            semantic=semantic,
-            byte_position=byte_position,
-            bit_position=bit_position,
-            dop_ref=dop_ref,
-            dop_snref=dop_snref,
-            physical_default_value_raw=physical_default_value_raw,
-            sdgs=sdgs,
-            **kwargs)
-
-    elif parameter_type == "PHYS-CONST":
-        physical_constant_value = odxrequire(et_element.findtext("PHYS-CONSTANT-VALUE"))
-
-        return PhysicalConstantParameter(
-            semantic=semantic,
-            byte_position=byte_position,
-            bit_position=bit_position,
-            dop_ref=dop_ref,
-            dop_snref=dop_snref,
-            physical_constant_value_raw=physical_constant_value,
-            sdgs=sdgs,
-            **kwargs)
-
+        return ValueParameter.from_et(et_element, doc_frags)
     elif parameter_type == "CODED-CONST":
-        dct_elem = odxrequire(et_element.find("DIAG-CODED-TYPE"))
-        diag_coded_type = create_any_diag_coded_type_from_et(dct_elem, doc_frags)
-        coded_value = diag_coded_type.base_data_type.from_string(
-            odxrequire(et_element.findtext("CODED-VALUE")))
-
-        return CodedConstParameter(
-            semantic=semantic,
-            diag_coded_type=diag_coded_type,
-            coded_value=coded_value,
-            byte_position=byte_position,
-            bit_position=bit_position,
-            sdgs=sdgs,
-            **kwargs)
-
+        return CodedConstParameter.from_et(et_element, doc_frags)
+    elif parameter_type == "PHYS-CONST":
+        return PhysicalConstantParameter.from_et(et_element, doc_frags)
+    elif parameter_type == "SYSTEM":
+        return SystemParameter.from_et(et_element, doc_frags)
+    elif parameter_type == "LENGTH-KEY":
+        return LengthKeyParameter.from_et(et_element, doc_frags)
     elif parameter_type == "NRC-CONST":
-        diag_coded_type = create_any_diag_coded_type_from_et(
-            odxrequire(et_element.find("DIAG-CODED-TYPE")), doc_frags)
-        coded_values = [
-            diag_coded_type.base_data_type.from_string(odxrequire(val.text))
-            for val in et_element.iterfind("CODED-VALUES/CODED-VALUE")
-        ]
-
-        return NrcConstParameter(
-            semantic=semantic,
-            diag_coded_type=diag_coded_type,
-            coded_values=coded_values,
-            byte_position=byte_position,
-            bit_position=bit_position,
-            sdgs=sdgs,
-            **kwargs)
-
+        return NrcConstParameter.from_et(et_element, doc_frags)
     elif parameter_type == "RESERVED":
-        bit_length = int(odxrequire(et_element.findtext("BIT-LENGTH")))
-
-        return ReservedParameter(
-            bit_length=bit_length,
-            semantic=semantic,
-            byte_position=byte_position,
-            bit_position=bit_position,
-            sdgs=sdgs,
-            **kwargs)
-
+        return ReservedParameter.from_et(et_element, doc_frags)
     elif parameter_type == "MATCHING-REQUEST-PARAM":
-        byte_length = int(odxrequire(et_element.findtext("BYTE-LENGTH")))
-        request_byte_pos = int(odxrequire(et_element.findtext("REQUEST-BYTE-POS")))
-
-        return MatchingRequestParameter(
-            semantic=semantic,
-            byte_position=byte_position,
-            bit_position=bit_position,
-            request_byte_position=request_byte_pos,
-            byte_length=byte_length,
-            sdgs=sdgs,
-            **kwargs)
-
-    elif parameter_type == "SYSTEM":
-        sysparam = odxrequire(et_element.get("SYSPARAM"))
-
-        return SystemParameter(
-            sysparam=sysparam,
-            semantic=semantic,
-            byte_position=byte_position,
-            bit_position=bit_position,
-            dop_ref=dop_ref,
-            dop_snref=dop_snref,
-            sdgs=sdgs,
-            **kwargs)
-
-    elif parameter_type == "LENGTH-KEY":
-        odx_id = odxrequire(OdxLinkId.from_et(et_element, doc_frags))
-
-        return LengthKeyParameter(
-            odx_id=odx_id,
-            semantic=semantic,
-            byte_position=byte_position,
-            bit_position=bit_position,
-            dop_ref=dop_ref,
-            dop_snref=dop_snref,
-            sdgs=sdgs,
-            **kwargs)
-
+        return MatchingRequestParameter.from_et(et_element, doc_frags)
     elif parameter_type == "DYNAMIC":
-
-        return DynamicParameter(
-            semantic=semantic,
-            byte_position=byte_position,
-            bit_position=bit_position,
-            sdgs=sdgs,
-            **kwargs)
-
+        return DynamicParameter.from_et(et_element, doc_frags)
     elif parameter_type == "TABLE-STRUCT":
-        key_ref = OdxLinkRef.from_et(et_element.find("TABLE-KEY-REF"), doc_frags)
-        if (key_snref_elem := et_element.find("TABLE-KEY-SNREF")) is not None:
-            key_snref = odxrequire(key_snref_elem.get("SHORT-NAME"))
-        else:
-            key_snref = None
-
-        return TableStructParameter(
-            table_key_ref=key_ref,
-            table_key_snref=key_snref,
-            semantic=semantic,
-            byte_position=byte_position,
-            bit_position=bit_position,
-            sdgs=sdgs,
-            **kwargs)
-
+        return TableStructParameter.from_et(et_element, doc_frags)
     elif parameter_type == "TABLE-KEY":
-
-        parameter_id = odxrequire(OdxLinkId.from_et(et_element, doc_frags))
-        table_ref = OdxLinkRef.from_et(et_element.find("TABLE-REF"), doc_frags)
-        if (table_snref_elem := et_element.find("TABLE-SNREF")) is not None:
-            table_snref = odxrequire(table_snref_elem.get("SHORT-NAME"))
-        else:
-            table_snref = None
-
-        table_row_ref = OdxLinkRef.from_et(et_element.find("TABLE-ROW-REF"), doc_frags)
-        if (table_row_snref_elem := et_element.find("TABLE-ROW-SNREF")) is not None:
-            table_row_snref = odxrequire(table_row_snref_elem.get("SHORT-NAME"))
-        else:
-            table_row_snref = None
-
-        return TableKeyParameter(
-            table_ref=table_ref,
-            table_snref=table_snref,
-            table_row_snref=table_row_snref,
-            table_row_ref=table_row_ref,
-            odx_id=parameter_id,
-            byte_position=byte_position,
-            bit_position=bit_position,
-            semantic=semantic,
-            sdgs=sdgs,
-            **kwargs)
-
+        return TableKeyParameter.from_et(et_element, doc_frags)
     elif parameter_type == "TABLE-ENTRY":
-        target = odxrequire(et_element.findtext("TARGET"))
-        table_row_ref = odxrequire(OdxLinkRef.from_et(et_element.find("TABLE-ROW-REF"), doc_frags))
-
-        return TableEntryParameter(
-            target=target,
-            table_row_ref=table_row_ref,
-            byte_position=byte_position,
-            bit_position=bit_position,
-            semantic=semantic,
-            sdgs=sdgs,
-            **kwargs)
+        return TableEntryParameter.from_et(et_element, doc_frags)
 
-    raise NotImplementedError(f"I don't know about parameters of type {parameter_type}")
+    odxraise(f"I don't know about parameters of type {parameter_type}", NotImplementedError)
+    return Parameter.from_et(et_element, doc_frags)

odxtools/parameters/dynamicparameter.py

@@ -1,29 +1,50 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
+from typing import List, Optional
+from xml.etree import ElementTree
+
+from typing_extensions import override
 
 from ..decodestate import DecodeState
 from ..encodestate import EncodeState
+from ..odxlink import OdxDocFragment
 from ..odxtypes import ParameterValue
+from ..utils import dataclass_fields_asdict
 from .parameter import Parameter, ParameterType
 
 
 @dataclass
 class DynamicParameter(Parameter):
 
+    @staticmethod
+    @override
+    def from_et(et_element: ElementTree.Element,
+                doc_frags: List[OdxDocFragment]) -> "DynamicParameter":
+
+        kwargs = dataclass_fields_asdict(Parameter.from_et(et_element, doc_frags))
+
+        return DynamicParameter(**kwargs)
+
     @property
+    @override
     def parameter_type(self) -> ParameterType:
         return "DYNAMIC"
 
     @property
+    @override
     def is_required(self) -> bool:
         raise NotImplementedError(".is_required for a DynamicParameter")
 
     @property
+    @override
     def is_settable(self) -> bool:
         raise NotImplementedError(".is_settable for a DynamicParameter")
 
-    def get_coded_value_as_bytes(self, encode_state: EncodeState) -> bytes:
-        raise NotImplementedError("Encoding a DynamicParameter is not implemented yet.")
+    @override
+    def _encode_positioned_into_pdu(self, physical_value: Optional[ParameterValue],
+                                    encode_state: EncodeState) -> None:
+        raise NotImplementedError("Encoding DynamicParameter is not implemented yet.")
 
-    def decode_from_pdu(self, decode_state: DecodeState) -> ParameterValue:
-        raise NotImplementedError("Decoding a DynamicParameter is not implemented yet.")
+    @override
+    def _decode_positioned_from_pdu(self, decode_state: DecodeState) -> ParameterValue:
+        raise NotImplementedError("Decoding DynamicParameter is not implemented yet.")

odxtools/parameters/lengthkeyparameter.py

@@ -1,18 +1,19 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Dict
+from typing import Any, Dict, List, Optional
+from xml.etree import ElementTree
+
+from typing_extensions import final, override
 
 from ..decodestate import DecodeState
 from ..encodestate import EncodeState
-from ..exceptions import odxraise, odxrequire
-from ..odxlink import OdxLinkDatabase, OdxLinkId
+from ..exceptions import EncodeError, odxraise, odxrequire
+from ..odxlink import OdxDocFragment, OdxLinkId
 from ..odxtypes import ParameterValue
+from ..utils import dataclass_fields_asdict
 from .parameter import ParameterType
 from .parameterwithdop import ParameterWithDOP
 
-if TYPE_CHECKING:
-    from ..diaglayer import DiagLayer
-
 
 @dataclass
 class LengthKeyParameter(ParameterWithDOP):
@@ -27,10 +28,23 @@ class LengthKeyParameter(ParameterWithDOP):
 
     odx_id: OdxLinkId
 
+    @staticmethod
+    @override
+    def from_et(et_element: ElementTree.Element,
+                doc_frags: List[OdxDocFragment]) -> "LengthKeyParameter":
+
+        kwargs = dataclass_fields_asdict(ParameterWithDOP.from_et(et_element, doc_frags))
+
+        odx_id = odxrequire(OdxLinkId.from_et(et_element, doc_frags))
+
+        return LengthKeyParameter(odx_id=odx_id, **kwargs)
+
     @property
+    @override
     def parameter_type(self) -> ParameterType:
         return "LENGTH-KEY"
 
+    @override
     def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
         result = super()._build_odxlinks()
 
@@ -38,36 +52,80 @@ class LengthKeyParameter(ParameterWithDOP):
 
         return result
 
-    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
-        super()._resolve_odxlinks(odxlinks)
-
-    def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
-        super()._resolve_snrefs(diag_layer)
-
     @property
+    @override
     def is_required(self) -> bool:
         return False
 
     @property
+    @override
     def is_settable(self) -> bool:
         # length keys can be explicitly set, but they do not need to
         # be because they can be implicitly determined by the length
         # of the corresponding field
         return True
 
-    def get_coded_value_as_bytes(self, encode_state: EncodeState) -> bytes:
-        physical_value = encode_state.parameter_values.get(self.short_name, 0)
-
-        bit_pos = self.bit_position or 0
-        dop = odxrequire(super().dop,
-                         f"A DOP is required for length key parameter {self.short_name}")
-        return dop.convert_physical_to_bytes(physical_value, encode_state, bit_position=bit_pos)
-
-    def encode_into_pdu(self, encode_state: EncodeState) -> bytes:
-        return super().encode_into_pdu(encode_state)
-
-    def decode_from_pdu(self, decode_state: DecodeState) -> ParameterValue:
-        phys_val = super().decode_from_pdu(decode_state)
+    @override
+    @final
+    def _encode_positioned_into_pdu(self, physical_value: Optional[ParameterValue],
+                                    encode_state: EncodeState) -> None:
+        # if you get this exception, you ought to use
+        # `.encode_placeholder_into_pdu()` followed by (after the
+        # value of the length key has been determined)
+        # `.encode_value_into_pdu()`.
+        raise RuntimeError("_encode_positioned_into_pdu() cannot be called for length keys.")
+
+    def encode_placeholder_into_pdu(self, physical_value: Optional[ParameterValue],
+                                    encode_state: EncodeState) -> None:
+
+        if physical_value is not None:
+            if not self.dop.is_valid_physical_value(physical_value):
+                odxraise(f"Invalid explicitly specified physical value '{physical_value!r}' "
+                         f"for length key '{self.short_name}'.")
+
+            lkv = encode_state.length_keys.get(self.short_name)
+            if lkv is not None and lkv != physical_value:
+                odxraise(f"Got conflicting values for length key {self.short_name}: "
+                         f"{lkv} and {physical_value!r}")
+
+            if not isinstance(physical_value, int):
+                odxraise(
+                    f"Value of length key {self.short_name} is of type {type(physical_value).__name__} "
+                    f"instead of int")
+
+            encode_state.length_keys[self.short_name] = physical_value
+
+        pos = encode_state.cursor_byte_position
+        if self.byte_position is not None:
+            pos = encode_state.origin_byte_position + self.byte_position
+        encode_state.key_pos[self.short_name] = pos
+        encode_state.cursor_byte_position = pos
+        encode_state.cursor_bit_position = self.bit_position or 0
+
+        # emplace a value of zero into the encode state, but pretend the bits not to be used
+        n = odxrequire(self.dop.get_static_bit_length()) + encode_state.cursor_bit_position
+        tmp_val = b'\x00' * ((n + 7) // 8)
+        encode_state.cursor_bit_position = 0
+        encode_state.emplace_bytes(tmp_val, obj_used_mask=tmp_val)
+
+    def encode_value_into_pdu(self, encode_state: EncodeState) -> None:
+
+        if self.short_name not in encode_state.length_keys:
+            odxraise(
+                f"Length key {self.short_name} has not been defined before "
+                f"it is required.", EncodeError)
+            return
+        else:
+            physical_value = encode_state.length_keys[self.short_name]
+
+        encode_state.cursor_byte_position = encode_state.key_pos[self.short_name]
+        encode_state.cursor_bit_position = self.bit_position or 0
+
+        self.dop.encode_into_pdu(encode_state=encode_state, physical_value=physical_value)
+
+    @override
+    def _decode_positioned_from_pdu(self, decode_state: DecodeState) -> ParameterValue:
+        phys_val = super()._decode_positioned_from_pdu(decode_state)
 
         if not isinstance(phys_val, int):
             odxraise(f"The pysical type of length keys must be an integer, "

odxtools/parameters/matchingrequestparameter.py

@@ -1,11 +1,16 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import Optional
+from typing import List, Optional
+from xml.etree import ElementTree
+
+from typing_extensions import override
 
 from ..decodestate import DecodeState
 from ..encodestate import EncodeState
-from ..exceptions import EncodeError
+from ..exceptions import EncodeError, odxraise, odxrequire
+from ..odxlink import OdxDocFragment
 from ..odxtypes import DataType, ParameterValue
+from ..utils import dataclass_fields_asdict
 from .parameter import Parameter, ParameterType
 
 
@@ -14,39 +19,64 @@ class MatchingRequestParameter(Parameter):
     request_byte_position: int
     byte_length: int
 
+    @staticmethod
+    @override
+    def from_et(et_element: ElementTree.Element,
+                doc_frags: List[OdxDocFragment]) -> "MatchingRequestParameter":
+
+        kwargs = dataclass_fields_asdict(Parameter.from_et(et_element, doc_frags))
+
+        request_byte_position = int(odxrequire(et_element.findtext("REQUEST-BYTE-POS")))
+        byte_length = int(odxrequire(et_element.findtext("BYTE-LENGTH")))
+
+        return MatchingRequestParameter(
+            request_byte_position=request_byte_position, byte_length=byte_length, **kwargs)
+
     @property
+    @override
     def parameter_type(self) -> ParameterType:
         return "MATCHING-REQUEST-PARAM"
 
+    @override
     def get_static_bit_length(self) -> Optional[int]:
         return 8 * self.byte_length
 
     @property
+    @override
     def is_required(self) -> bool:
         return False
 
     @property
+    @override
     def is_settable(self) -> bool:
         return False
 
-    def get_coded_value_as_bytes(self, encode_state: EncodeState) -> bytes:
-        if not encode_state.triggering_request:
-            raise EncodeError(f"Parameter '{self.short_name}' is of matching request type,"
-                              " but no original request has been specified.")
-        return encode_state.triggering_request[self
-                                               .request_byte_position:self.request_byte_position +
-                                               self.byte_length]
+    @override
+    def _encode_positioned_into_pdu(self, physical_value: Optional[ParameterValue],
+                                    encode_state: EncodeState) -> None:
+        if encode_state.triggering_request is None:
+            odxraise(
+                f"Parameter '{self.short_name}' is of matching request type,"
+                f" but no original request has been specified.", EncodeError)
+            return
 
-    def decode_from_pdu(self, decode_state: DecodeState) -> ParameterValue:
-        orig_cursor = decode_state.cursor_byte_position
-        if self.byte_position is not None:
-            decode_state.cursor_byte_position = decode_state.origin_byte_position + self.byte_position
+        rq_pos = self.request_byte_position
+        rq_len = self.byte_length
 
-        result = decode_state.extract_atomic_value(
+        if len(encode_state.triggering_request) < rq_pos + rq_len:
+            odxraise(
+                f"Specified triggering request 0x{encode_state.triggering_request.hex()} "
+                f"is not long enough to encode matching request parameter "
+                f"'{self.short_name}': Have {len(encode_state.triggering_request)} "
+                f"bytes, need at least {rq_pos + rq_len} bytes", EncodeError)
+            return
+
+        encode_state.emplace_bytes(encode_state.triggering_request[rq_pos:rq_pos + rq_len],
+                                   self.short_name)
+
+    @override
+    def _decode_positioned_from_pdu(self, decode_state: DecodeState) -> ParameterValue:
+        return decode_state.extract_atomic_value(
             bit_length=self.byte_length * 8,
             base_data_type=DataType.A_UINT32,
             is_highlow_byte_order=False)
-
-        decode_state.cursor_byte_position = max(decode_state.cursor_byte_position, orig_cursor)
-
-        return result