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

odxtools/parameters/nrcconstparameter.py

@@ -1,7 +1,6 @@
 # SPDX-License-Identifier: MIT
-import warnings
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Dict, List, Optional
+from typing import Any, Dict, List, Optional
 from xml.etree import ElementTree
 
 from typing_extensions import override
@@ -10,25 +9,29 @@ 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, odxrequire
-from ..odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
-from ..odxtypes import AtomicOdxType, DataType
+from ..exceptions import DecodeMismatch, EncodeError, odxraise, odxrequire
+from ..odxlink import OdxDocFragment, OdxLinkId
+from ..odxtypes import AtomicOdxType, DataType, ParameterValue
 from ..utils import dataclass_fields_asdict
 from .parameter import Parameter, ParameterType
 
-if TYPE_CHECKING:
-    from ..diaglayer import DiagLayer
-
 
 @dataclass
 class NrcConstParameter(Parameter):
-    """A param of type NRC-CONST defines a set of values to be matched.
-
-    An NRC-CONST can only be used in a negative response.
-    Its encoding behaviour is similar to a VALUE parameter with a TEXTTABLE.
-    However, an NRC-CONST is used for matching a response (similar to a CODED-CONST).
+    """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
+    apply to a binary string, but in contrast to CODED-CONST
+    parameters they allow to specify multiple values. Thus, the value
+    of a CODED-CONST parameter is usually set using an overlapping
+    VALUE parameter. Since NRC-CONST parameters can only be specified
+    for negative responses, they can thus be regarded as a multiplexer
+    mechanism that is specific to negative responses.
 
     See ASAM MCD-2 D (ODX), p. 77-79.
+
     """
 
     diag_coded_type: DiagCodedType
@@ -64,14 +67,6 @@ class NrcConstParameter(Parameter):
 
         return result
 
-    @override
-    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
-        super()._resolve_odxlinks(odxlinks)
-
-    @override
-    def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
-        super()._resolve_snrefs(diag_layer)
-
     @override
     def get_static_bit_length(self) -> Optional[int]:
         return self.diag_coded_type.get_static_bit_length()
@@ -91,38 +86,42 @@ class NrcConstParameter(Parameter):
         return False
 
     @override
-    def get_coded_value_as_bytes(self, encode_state: EncodeState) -> bytes:
-        if self.short_name in encode_state.parameter_values:
-            if encode_state.parameter_values[self.short_name] not in self.coded_values:
-                raise EncodeError(f"The parameter '{self.short_name}' must have"
-                                  f" one of the constant values {self.coded_values}")
-            else:
-                coded_value = encode_state.parameter_values[self.short_name]
-        else:
-            # If the user does not select one, just select any.
-            # I think it does not matter ...
-            coded_value = self.coded_values[0]
-
-        bit_position_int = self.bit_position if self.bit_position is not None else 0
-        return self.diag_coded_type.convert_internal_to_bytes(
-            coded_value, encode_state, bit_position=bit_position_int)
+    def _encode_positioned_into_pdu(self, physical_value: Optional[ParameterValue],
+                                    encode_state: EncodeState) -> None:
+        # 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:
+            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
+
+        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/parameter.py

@@ -1,22 +1,19 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Dict, List, Literal, Optional
+from typing import Any, Dict, List, Literal, Optional
 from xml.etree import ElementTree
 
 from typing_extensions import final, override
 
-from ..createsdgs import create_sdgs_from_et
 from ..decodestate import DecodeState
 from ..element import NamedElement
 from ..encodestate import EncodeState
 from ..odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
 from ..odxtypes import ParameterValue
+from ..snrefcontext import SnRefContext
 from ..specialdatagroup import SpecialDataGroup
 from ..utils import dataclass_fields_asdict
 
-if TYPE_CHECKING:
-    from ..diaglayer import DiagLayer
-
 ParameterType = Literal[
     "CODED-CONST",
     "DYNAMIC",
@@ -36,13 +33,16 @@ 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]
     byte_position: Optional[int]
     bit_position: Optional[int]
     semantic: Optional[str]
@@ -54,8 +54,11 @@ class Parameter(NamedElement):
 
         kwargs = dataclass_fields_asdict(NamedElement.from_et(et_element, doc_frags))
 
+        oid = et_element.get("OID")
         semantic = et_element.get("SEMANTIC")
-        sdgs = create_sdgs_from_et(et_element.find("SDGS"), doc_frags)
+        sdgs = [
+            SpecialDataGroup.from_et(sdge, doc_frags) for sdge in et_element.iterfind("SDGS/SDG")
+        ]
 
         byte_position_str = et_element.findtext("BYTE-POSITION")
         bit_position_str = et_element.findtext("BIT-POSITION")
@@ -64,6 +67,7 @@ class Parameter(NamedElement):
         bit_position = int(bit_position_str) if bit_position_str is not None else None
 
         return Parameter(
+            oid=oid,
             byte_position=byte_position,
             bit_position=bit_position,
             semantic=semantic,
@@ -82,9 +86,9 @@ class Parameter(NamedElement):
         for sdg in self.sdgs:
             sdg._resolve_odxlinks(odxlinks)
 
-    def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
         for sdg in self.sdgs:
-            sdg._resolve_snrefs(diag_layer)
+            sdg._resolve_snrefs(context)
 
     @property
     def parameter_type(self) -> ParameterType:
@@ -117,16 +121,47 @@ class Parameter(NamedElement):
         """
         raise NotImplementedError(".is_settable is not implemented by the concrete parameter class")
 
-    def get_coded_value_as_bytes(self, encode_state: EncodeState) -> bytes:
-        """Get the coded value of the parameter given the encode state.
-        Note that this method is called by `encode_into_pdu`.
+    @final
+    def encode_into_pdu(self, physical_value: Optional[ParameterValue],
+                        encode_state: EncodeState) -> None:
+        """Convert a physical value into its encoded form and place it
+        into the PDU
+
+        Also, adapt the `encode_state` so that it points to where the
+        next parameter is located (if the next parameter does not
+        explicitly specify a position)
+
         """
+
+        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 = self.bit_position or 0
+
+        self._encode_positioned_into_pdu(physical_value, encode_state)
+
+        encode_state.cursor_bit_position = 0
+
+    def _encode_positioned_into_pdu(self, physical_value: Optional[ParameterValue],
+                                    encode_state: EncodeState) -> None:
+        """Method which actually encodes the parameter
+
+        Its location is managed by `Parameter`."""
         raise NotImplementedError(
-            ".get_coded_value_as_bytes() is not implemented by the concrete parameter class")
+            f"Required method '_encode_positioned_into_pdu()' not implemented by "
+            f"child class {type(self).__name__}")
 
     @final
     def decode_from_pdu(self, decode_state: DecodeState) -> ParameterValue:
-        orig_cursor = decode_state.cursor_byte_position
+        """Retrieve the raw data for the parameter from the PDU and
+        convert it to its physical interpretation
+
+        Also, adapt the `encode_state` so that it points to where the
+        next parameter is located (if the next parameter does not
+        explicitly specify a position)
+
+        """
+
         if self.byte_position is not None:
             decode_state.cursor_byte_position = decode_state.origin_byte_position + self.byte_position
 
@@ -134,7 +169,6 @@ class Parameter(NamedElement):
 
         result = self._decode_positioned_from_pdu(decode_state)
 
-        decode_state.cursor_byte_position = max(decode_state.cursor_byte_position, orig_cursor)
         decode_state.cursor_bit_position = 0
 
         return result
@@ -144,41 +178,5 @@ class Parameter(NamedElement):
 
         Its location is managed by `Parameter`."""
         raise NotImplementedError(
-            "Required method '_decode_positioned_from_pdu()' not implemented by child class")
-
-    def encode_into_pdu(self, encode_state: EncodeState) -> bytes:
-        """Encode the value of a parameter into a binary blob and return it
-
-        If the byte position of the parameter is not defined,
-        the byte code is appended to the blob.
-
-        Technical note for subclasses: The default implementation
-        tries to compute the coded value via
-        `self.get_coded_value_as_bytes(encoded_state)` and inserts it
-        into the PDU. Thus it usually suffices to overwrite
-        `get_coded_value_as_bytes()` instead of `encode_into_pdu()`.
-
-        Parameters:
-        ----------
-        encode_state: EncodeState, i.e. a named tuple with attributes
-            * coded_message: bytes, the message encoded so far
-            * parameter_values: List[ParameterValuePairs]
-            * triggering_coded_request: bytes
-
-        Returns:
-        -------
-        bytes
-            the message's blob after adding the encoded parameter into it
-
-        """
-        msg_blob = encode_state.coded_message
-        param_blob = self.get_coded_value_as_bytes(encode_state)
-
-        if self.byte_position is not None:
-            byte_position = self.byte_position
-        else:
-            byte_position = len(msg_blob)
-
-        encode_state.emplace_atomic_value(param_blob, self.short_name, byte_position)
-
-        return encode_state.coded_message
+            f"Required method '_decode_positioned_from_pdu()' not implemented by "
+            f"child class {type(self).__name__}")

odxtools/parameters/parameterwithdop.py

@@ -1,6 +1,6 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Dict, List, Optional
+from typing import Any, Dict, List, Optional, cast
 from xml.etree import ElementTree
 
 from typing_extensions import override
@@ -11,15 +11,13 @@ from ..dopbase import DopBase
 from ..dtcdop import DtcDop
 from ..encodestate import EncodeState
 from ..exceptions import odxassert, odxrequire
-from ..odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef
-from ..odxtypes import ParameterValue
+from ..odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef, resolve_snref
+from ..odxtypes import AtomicOdxType, ParameterValue
 from ..physicaltype import PhysicalType
+from ..snrefcontext import SnRefContext
 from ..utils import dataclass_fields_asdict
 from .parameter import Parameter
 
-if TYPE_CHECKING:
-    from ..diaglayer import DiagLayer
-
 
 @dataclass
 class ParameterWithDOP(Parameter):
@@ -43,7 +41,7 @@ class ParameterWithDOP(Parameter):
     def __post_init__(self) -> None:
         odxassert(self.dop_snref is not None or self.dop_ref is not None,
                   f"Param {self.short_name} without a DOP-(SN)REF should not exist!")
-        self._dop: Optional[DopBase] = None
+        self._dop: DopBase
 
     @override
     def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
@@ -55,26 +53,21 @@ class ParameterWithDOP(Parameter):
 
         if self.dop_ref is not None:
             odxassert(self.dop_snref is None)
-            # TODO: do not do lenient resolves here. The problem is
-            # that currently not all kinds of DOPs are internalized
-            # (e.g., static and dynamic fields)
-            self._dop = odxlinks.resolve_lenient(self.dop_ref)
+            self._dop = odxlinks.resolve(self.dop_ref)
 
     @override
-    def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
-        super()._resolve_snrefs(diag_layer)
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
+        super()._resolve_snrefs(context)
 
         if self.dop_snref:
-            ddds = diag_layer.diag_data_dictionary_spec
-            self._dop = odxrequire(ddds.all_data_object_properties.get(self.dop_snref))
+            ddds = odxrequire(context.diag_layer).diag_data_dictionary_spec
+            self._dop = resolve_snref(self.dop_snref, ddds.all_data_object_properties, DopBase)
 
     @property
     def dop(self) -> DopBase:
-        """may be a DataObjectProperty, a Structure or None"""
+        """This is usually a DataObjectProperty or a Structure object"""
 
-        return odxrequire(
-            self._dop, "Specifying a data object property is mandatory but it "
-            "could not be resolved")
+        return self._dop
 
     @override
     def get_static_bit_length(self) -> Optional[int]:
@@ -91,12 +84,9 @@ class ParameterWithDOP(Parameter):
             return None
 
     @override
-    def get_coded_value_as_bytes(self, encode_state: EncodeState) -> bytes:
-        dop = odxrequire(self.dop, "Reference to DOP is not resolved")
-        physical_value = encode_state.parameter_values[self.short_name]
-        bit_position_int = self.bit_position if self.bit_position is not None else 0
-        return dop.convert_physical_to_bytes(
-            physical_value, encode_state, bit_position=bit_position_int)
+    def _encode_positioned_into_pdu(self, physical_value: Optional[ParameterValue],
+                                    encode_state: EncodeState) -> None:
+        self.dop.encode_into_pdu(cast(AtomicOdxType, physical_value), encode_state)
 
     @override
     def _decode_positioned_from_pdu(self, decode_state: DecodeState) -> ParameterValue:

odxtools/parameters/physicalconstantparameter.py

@@ -1,6 +1,6 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Dict, List
+from typing import Any, Dict, List, Optional
 from xml.etree import ElementTree
 
 from typing_extensions import override
@@ -8,16 +8,14 @@ from typing_extensions import override
 from ..dataobjectproperty import DataObjectProperty
 from ..decodestate import DecodeState
 from ..encodestate import EncodeState
-from ..exceptions import DecodeError, odxraise, odxrequire
+from ..exceptions import DecodeError, EncodeError, odxraise, odxrequire
 from ..odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
 from ..odxtypes import ParameterValue
+from ..snrefcontext import SnRefContext
 from ..utils import dataclass_fields_asdict
 from .parameter import ParameterType
 from .parameterwithdop import ParameterWithDOP
 
-if TYPE_CHECKING:
-    from ..diaglayer import DiagLayer
-
 
 @dataclass
 class PhysicalConstantParameter(ParameterWithDOP):
@@ -50,8 +48,8 @@ class PhysicalConstantParameter(ParameterWithDOP):
         super()._resolve_odxlinks(odxlinks)
 
     @override
-    def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
-        super()._resolve_snrefs(diag_layer)
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
+        super()._resolve_snrefs(context)
 
         dop = odxrequire(self.dop)
         if not isinstance(dop, DataObjectProperty):
@@ -74,17 +72,15 @@ class PhysicalConstantParameter(ParameterWithDOP):
         return False
 
     @override
-    def get_coded_value_as_bytes(self, encode_state: EncodeState) -> bytes:
-        dop = odxrequire(self.dop, "Reference to DOP is not resolved")
-        if (self.short_name in encode_state.parameter_values and
-                encode_state.parameter_values[self.short_name] != self.physical_constant_value):
-            raise TypeError(
-                f"The parameter '{self.short_name}' is constant {self.physical_constant_value!r}"
-                f" and thus can not be changed.")
-
-        bit_position_int = self.bit_position if self.bit_position is not None else 0
-        return dop.convert_physical_to_bytes(
-            self.physical_constant_value, encode_state, bit_position=bit_position_int)
+    def _encode_positioned_into_pdu(self, physical_value: Optional[ParameterValue],
+                                    encode_state: EncodeState) -> None:
+        if physical_value is not None and physical_value != self.physical_constant_value:
+            odxraise(
+                f"Value for constant parameter `{self.short_name}` name can "
+                f"only be specified as {self.physical_constant_value!r} (is: {physical_value!r})",
+                EncodeError)
+
+        self.dop.encode_into_pdu(self.physical_constant_value, encode_state)
 
     @override
     def _decode_positioned_from_pdu(self, decode_state: DecodeState) -> ParameterValue:
@@ -99,4 +95,5 @@ class PhysicalConstantParameter(ParameterWithDOP):
                 f"{self.physical_constant_value!r} but got {phys_val!r} "
                 f"at byte position {decode_state.cursor_byte_position} "
                 f"in coded message {decode_state.coded_message.hex()}.", DecodeError)
+
         return phys_val

odxtools/parameters/reservedparameter.py

@@ -49,8 +49,12 @@ class ReservedParameter(Parameter):
         return self.bit_length
 
     @override
-    def get_coded_value_as_bytes(self, encode_state: EncodeState) -> bytes:
-        return (0).to_bytes(((self.bit_position or 0) + self.bit_length + 7) // 8, "big")
+    def _encode_positioned_into_pdu(self, physical_value: Optional[ParameterValue],
+                                    encode_state: EncodeState) -> None:
+        encode_state.cursor_byte_position += (encode_state.cursor_bit_position + self.bit_length +
+                                              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) -> ParameterValue:

odxtools/parameters/systemparameter.py

@@ -1,19 +1,29 @@
 # SPDX-License-Identifier: MIT
+import getpass
 from dataclasses import dataclass
-from typing import List
+from datetime import datetime
+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 odxrequire
+from ..exceptions import odxraise, odxrequire
 from ..odxlink import OdxDocFragment
 from ..odxtypes import ParameterValue
 from ..utils import dataclass_fields_asdict
 from .parameter import ParameterType
 from .parameterwithdop import ParameterWithDOP
 
+# The SYSTEM parameter types mandated by the ODX 2.2 standard. Users
+# are free to specify additional types, but these must be handled
+# (cf. table 5 in section 7.3.5.4 of the ASAM ODX 2.2 specification
+# document.)
+PREDEFINED_SYSPARAM_VALUES = [
+    "TIMESTAMP", "SECOND", "MINUTE", "HOUR", "TIMEZONE", "DAY", "WEEK", "MONTH", "YEAR", "CENTURY",
+    "TESTERID", "USERID"
+]
+
 
 @dataclass
 class SystemParameter(ParameterWithDOP):
@@ -26,7 +36,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)
 
@@ -38,17 +48,51 @@ class SystemParameter(ParameterWithDOP):
     @property
     @override
     def is_required(self) -> bool:
-        raise NotImplementedError("SystemParameter.is_required is not implemented yet.")
+        # if a SYSTEM parameter is not specified explicitly, its value
+        # can be determined from the operating system if it is type is
+        # predefined
+        return self.sysparam not in PREDEFINED_SYSPARAM_VALUES
 
     @property
     @override
     def is_settable(self) -> bool:
-        raise NotImplementedError("SystemParameter.is_settable is not implemented yet.")
+        return True
 
     @override
-    def get_coded_value_as_bytes(self, encode_state: EncodeState) -> bytes:
-        raise NotImplementedError("Encoding a SystemParameter is not implemented yet.")
+    def _encode_positioned_into_pdu(self, physical_value: Optional[ParameterValue],
+                                    encode_state: EncodeState) -> None:
+        if physical_value is None:
+            # determine the value to be encoded automatically
+            now = datetime.now()
+            if self.sysparam == "TIMESTAMP":
+                physical_value = round(now.timestamp() * 1000).to_bytes(8, "big")
+            elif self.sysparam == "SECOND":
+                physical_value = now.second
+            elif self.sysparam == "MINUTE":
+                physical_value = now.minute
+            elif self.sysparam == "HOUR":
+                physical_value = now.hour
+            elif self.sysparam == "TIMEZONE":
+                if (utc_offset := now.astimezone().utcoffset()) is not None:
+                    physical_value = utc_offset.seconds // 60
+                else:
+                    physical_value = 0
+            elif self.sysparam == "DAY":
+                physical_value = now.day
+            elif self.sysparam == "WEEK":
+                physical_value = now.isocalendar()[1]
+            elif self.sysparam == "MONTH":
+                physical_value = now.month
+            elif self.sysparam == "YEAR":
+                physical_value = now.year
+            elif self.sysparam == "CENTURY":
+                physical_value = now.year // 100
+            elif self.sysparam == "TESTERID":
+                physical_value = "odxtools".encode("latin1")
+            elif self.sysparam == "USERID":
+                physical_value = getpass.getuser().encode("latin1")
+            else:
+                odxraise(f"Unknown system parameter type '{self.sysparam}'")
+                physical_value = 0
 
-    @override
-    def _decode_positioned_from_pdu(self, decode_state: DecodeState) -> ParameterValue:
-        raise NotImplementedError("Decoding SystemParameter is not implemented yet.")
+        self.dop.encode_into_pdu(physical_value, encode_state=encode_state)

odxtools/parameters/tableentryparameter.py

@@ -1,6 +1,6 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, List
+from typing import TYPE_CHECKING, List, Optional
 from xml.etree import ElementTree
 
 from typing_extensions import override
@@ -59,7 +59,8 @@ class TableEntryParameter(Parameter):
         raise NotImplementedError("TableEntryParameter.is_settable is not implemented yet.")
 
     @override
-    def get_coded_value_as_bytes(self, encode_state: EncodeState) -> bytes:
+    def _encode_positioned_into_pdu(self, physical_value: Optional[ParameterValue],
+                                    encode_state: EncodeState) -> None:
         raise NotImplementedError("Encoding a TableEntryParameter is not implemented yet.")
 
     @property