odxtools 6.7.1__py3-none-any.whl → 7.0.0__py3-none-any.whl

odxtools/minmaxlengthtype.py

@@ -2,6 +2,8 @@
 from dataclasses import dataclass
 from typing import Optional
 
+from typing_extensions import override
+
 from .decodestate import DecodeState
 from .diagcodedtype import DctType, DiagCodedType
 from .encodestate import EncodeState
@@ -51,8 +53,9 @@ class MinMaxLengthType(DiagCodedType):
                 termination_sequence = bytes([0xFF, 0xFF])
         return termination_sequence
 
-    def convert_internal_to_bytes(self, internal_value: AtomicOdxType, encode_state: EncodeState,
-                                  bit_position: int) -> bytes:
+    @override
+    def encode_into_pdu(self, internal_value: AtomicOdxType, encode_state: EncodeState) -> None:
+
         if not isinstance(internal_value, (bytes, str)):
             odxraise("MinMaxLengthType is currently only implemented for strings and byte arrays",
                      EncodeError)
@@ -62,20 +65,24 @@ class MinMaxLengthType(DiagCodedType):
         else:
             data_length = len(internal_value)
 
-        value_bytes = bytearray(
-            self._encode_internal_value(
-                internal_value,
-                bit_position=0,
-                bit_length=8 * data_length,
-                base_data_type=self.base_data_type,
-                is_highlow_byte_order=self.is_highlow_byte_order,
-            ))
+        orig_cursor = encode_state.cursor_byte_position
+        encode_state.emplace_atomic_value(
+            internal_value=internal_value,
+            used_mask=None,
+            bit_length=8 * data_length,
+            base_data_type=self.base_data_type,
+            is_highlow_byte_order=self.is_highlow_byte_order,
+        )
+        value_len = encode_state.cursor_byte_position - orig_cursor
 
         # TODO: ensure that the termination delimiter is not
         # encountered within the encoded value.
 
-        odxassert(self.termination != "END-OF-PDU" or encode_state.is_end_of_pdu)
-        if encode_state.is_end_of_pdu or len(value_bytes) == self.max_length:
+        odxassert(
+            self.termination != "END-OF-PDU" or encode_state.is_end_of_pdu,
+            "Encountered a MIN-MAX-LENGTH type with END-OF-PDU termination "
+            "which is not located at the end of the PDU")
+        if encode_state.is_end_of_pdu or value_len == self.max_length:
             # All termination types may be ended by the end of the PDU
             # or once reaching the maximum length. In this case, we
             # must not add the termination sequence
@@ -85,20 +92,23 @@ class MinMaxLengthType(DiagCodedType):
 
             # ensure that we don't try to encode an odd-length
             # value when using a two-byte terminator
-            odxassert(len(value_bytes) % len(termination_sequence) == 0)
-
-            value_bytes.extend(termination_sequence)
-
-        if len(value_bytes) < self.min_length:
-            raise EncodeError(f"Encoded value for MinMaxLengthType "
-                              f"must be at least {self.min_length} bytes long. "
-                              f"(Is: {len(value_bytes)} bytes.)")
-        elif self.max_length is not None and len(value_bytes) > self.max_length:
-            raise EncodeError(f"Encoded value for MinMaxLengthType "
-                              f"must not be longer than {self.max_length} bytes. "
-                              f"(Is: {len(value_bytes)} bytes.)")
-
-        return value_bytes
+            odxassert(value_len % len(termination_sequence) == 0)
+
+            value_len += len(termination_sequence)
+            encode_state.emplace_bytes(termination_sequence)
+
+        if value_len < self.min_length:
+            odxraise(
+                f"Encoded value for MinMaxLengthType "
+                f"must be at least {self.min_length} bytes long. "
+                f"(Is: {value_len} bytes.)", EncodeError)
+            return
+        elif self.max_length is not None and value_len > self.max_length:
+            odxraise(
+                f"Encoded value for MinMaxLengthType "
+                f"must not be longer than {self.max_length} bytes. "
+                f"(Is: {value_len} bytes.)", EncodeError)
+            return
 
     def decode_from_pdu(self, decode_state: DecodeState) -> AtomicOdxType:
         odxassert(decode_state.cursor_bit_position == 0,

odxtools/multiplexer.py

@@ -3,6 +3,8 @@ from dataclasses import dataclass
 from typing import TYPE_CHECKING, Any, Dict, List, Optional, Tuple
 from xml.etree import ElementTree
 
+from typing_extensions import override
+
 from .complexdop import ComplexDop
 from .decodestate import DecodeState
 from .encodestate import EncodeState
@@ -34,6 +36,7 @@ class Multiplexer(ComplexDop):
     is_visible_raw: Optional[bool]
 
     @staticmethod
+    @override
     def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "Multiplexer":
         """Reads a Multiplexer from Diag Layer."""
         base_obj = ComplexDop.from_et(et_element, doc_frags)
@@ -67,50 +70,63 @@ class Multiplexer(ComplexDop):
 
     def _get_case_limits(self, case: MultiplexerCase) -> Tuple[AtomicOdxType, AtomicOdxType]:
         key_type = self.switch_key.dop.physical_type.base_data_type
-        lower_limit = key_type.make_from(case.lower_limit)
-        upper_limit = key_type.make_from(case.upper_limit)
+        lower_limit = key_type.make_from(case.lower_limit.value)
+        upper_limit = key_type.make_from(case.upper_limit.value)
         if not isinstance(lower_limit, type(upper_limit)) and not isinstance(
                 upper_limit, type(lower_limit)):
             odxraise("Upper and lower bounds of limits must compareable")
         return lower_limit, upper_limit
 
-    def convert_physical_to_bytes(self,
-                                  physical_value: ParameterValue,
-                                  encode_state: EncodeState,
-                                  bit_position: int = 0) -> bytes:
+    @override
+    def encode_into_pdu(self, physical_value: ParameterValue, encode_state: EncodeState) -> None:
 
-        if bit_position != 0:
-            raise EncodeError("Multiplexer must be aligned, i.e. bit_position=0, but "
-                              f"{self.short_name} was passed the bit position {bit_position}")
+        if encode_state.cursor_bit_position != 0:
+            raise EncodeError(f"Multiplexer must be aligned, i.e. bit_position=0, but "
+                              f"{self.short_name} was passed the bit position "
+                              f"{encode_state.cursor_bit_position}")
 
         if not isinstance(physical_value, dict) or len(physical_value) != 1:
             raise EncodeError("""Multiplexer should be defined as a dict
             with only one key equal to the desired case""")
 
+        orig_origin = encode_state.origin_byte_position
+        orig_cursor = encode_state.cursor_byte_position
+
+        encode_state.origin_byte_position = encode_state.cursor_byte_position
+
         case_name, case_value = next(iter(physical_value.items()))
-        case_pos = self.byte_position
 
         for mux_case in self.cases or []:
             if mux_case.short_name == case_name:
-                if mux_case._structure:
-                    case_bytes = mux_case._structure.convert_physical_to_bytes(
-                        case_value, encode_state, 0)
-                else:
-                    case_bytes = b''
-
                 key_value, _ = self._get_case_limits(mux_case)
-                key_bytes = self.switch_key.dop.convert_physical_to_bytes(
-                    key_value, encode_state, bit_position=self.switch_key.bit_position or 0)
 
-                mux_len = max(len(key_bytes), len(case_bytes) + case_pos)
-                mux_bytes = bytearray(mux_len)
-                mux_bytes[:len(key_bytes)] = key_bytes
-                mux_bytes[case_pos:case_pos + len(case_bytes)] = case_bytes
+                if self.switch_key.byte_position is not None:
+                    encode_state.cursor_byte_position = encode_state.origin_byte_position + self.switch_key.byte_position
+                encode_state.cursor_bit_position = self.switch_key.bit_position or 0
+
+                self.switch_key.dop.encode_into_pdu(
+                    physical_value=key_value, encode_state=encode_state)
+
+                if self.byte_position is not None:
+                    encode_state.cursor_byte_position = encode_state.origin_byte_position + self.byte_position
+                encode_state.cursor_bit_position = 0
+
+                if mux_case._structure is None:
+                    odxraise(f"Multiplexer case '{mux_case.short_name}' does not "
+                             f"reference a structure.")
+                    return
+
+                mux_case.structure.encode_into_pdu(
+                    physical_value=key_value, encode_state=encode_state)
 
-                return bytes(mux_bytes)
+                encode_state.origin_byte_position = orig_origin
+                encode_state.cursor_byte_position = max(orig_cursor,
+                                                        encode_state.cursor_byte_position)
+                return
 
         raise EncodeError(f"The case {case_name} is not found in Multiplexer {self.short_name}")
 
+    @override
     def decode_from_pdu(self, decode_state: DecodeState) -> ParameterValue:
 
         # multiplexers are structures and thus the origin position
@@ -152,6 +168,7 @@ class Multiplexer(ComplexDop):
 
         return mux_value
 
+    @override
     def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
         odxlinks = super()._build_odxlinks()
 
@@ -161,6 +178,7 @@ class Multiplexer(ComplexDop):
 
         return odxlinks
 
+    @override
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
         super()._resolve_odxlinks(odxlinks)
 
@@ -172,6 +190,7 @@ class Multiplexer(ComplexDop):
             mux_case._mux_case_resolve_odxlinks(
                 odxlinks, key_physical_type=self.switch_key.dop.physical_type.base_data_type)
 
+    @override
     def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
         super()._resolve_snrefs(diag_layer)
 

odxtools/multiplexercase.py

@@ -60,7 +60,7 @@ class MultiplexerCase(NamedElement):
 
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
         raise RuntimeError("Calling MultiplexerCase._resolve_odxlinks() is not allowed. "
-                           "Use ._mux_case_resolve_odxlinks()().")
+                           "Use ._mux_case_resolve_odxlinks().")
 
     def _mux_case_resolve_odxlinks(self, odxlinks: OdxLinkDatabase, *,
                                    key_physical_type: DataType) -> None:

odxtools/nameditemlist.py

@@ -1,5 +1,6 @@
 # SPDX-License-Identifier: MIT
 import abc
+from copy import deepcopy
 from keyword import iskeyword
 from typing import (Any, Collection, Dict, Iterable, List, Optional, Protocol, SupportsIndex, Tuple,
                     TypeVar, Union, cast, overload, runtime_checkable)
@@ -175,6 +176,19 @@ class ItemAttributeList(List[T]):
     def __repr__(self) -> str:
         return f"{type(self).__name__}([{', '.join([repr(x) for x in self])}])"
 
+    def __copy__(self) -> Any:
+        return self.__class__(list(self))
+
+    def __deepcopy__(self, memo: Dict[int, Any]) -> Any:
+        cls = self.__class__
+        result = cls.__new__(cls)
+        memo[id(self)] = result
+        result._item_dict = {}
+        for x in self:
+            result.append(deepcopy(x, memo))
+
+        return result
+
 
 class NamedItemList(ItemAttributeList[T]):
 

odxtools/odxtypes.py

@@ -154,6 +154,19 @@ def compare_odx_values(a: AtomicOdxType, b: AtomicOdxType) -> int:
              f"and {type(b).__name__}")
 
 
+# format specifiers for the data type using the bitstruct module
+_BITSTRUCT_FORMAT_LETTER_MAP__ = {
+    "A_INT32": "s",
+    "A_UINT32": "u",
+    "A_FLOAT32": "f",
+    "A_FLOAT64": "f",
+    "A_BYTEFIELD": "r",
+    "A_UNICODE2STRING": "r",  # UTF-16 strings must be converted explicitly
+    "A_ASCIISTRING": "r",
+    "A_UTF8STRING": "r",
+}
+
+
 class DataType(Enum):
     """Types for the physical and internal value.
 
@@ -181,6 +194,10 @@ class DataType(Enum):
     def python_type(self) -> Type[AtomicOdxType]:
         return _ODX_TYPE_TO_PYTHON_TYPE[self.value]
 
+    @property
+    def bitstruct_format_letter(self) -> str:
+        return _BITSTRUCT_FORMAT_LETTER_MAP__[self.value]
+
     def from_string(self, value: str) -> AtomicOdxType:
         return _PARSE_ODX_TYPE[self.value](value)
 

odxtools/parameterinfo.py

@@ -1,105 +1,191 @@
 # SPDX-License-Identifier: MIT
-import re
-from typing import Iterable, Union
+import textwrap
+from io import StringIO
+from typing import Iterable
 
 from .compumethods.identicalcompumethod import IdenticalCompuMethod
 from .compumethods.limit import IntervalType
 from .compumethods.linearcompumethod import LinearCompuMethod
 from .compumethods.texttablecompumethod import TexttableCompuMethod
 from .dataobjectproperty import DataObjectProperty
+from .dtcdop import DtcDop
+from .dynamiclengthfield import DynamicLengthField
 from .endofpdufield import EndOfPduField
+from .exceptions import odxrequire
+from .multiplexer import Multiplexer
 from .odxtypes import DataType
 from .parameters.codedconstparameter import CodedConstParameter
 from .parameters.matchingrequestparameter import MatchingRequestParameter
+from .parameters.nrcconstparameter import NrcConstParameter
 from .parameters.parameter import Parameter
 from .parameters.parameterwithdop import ParameterWithDOP
 from .parameters.reservedparameter import ReservedParameter
+from .parameters.tablekeyparameter import TableKeyParameter
+from .parameters.tablestructparameter import TableStructParameter
+from .paramlengthinfotype import ParamLengthInfoType
+from .staticfield import StaticField
 
 
-def parameter_info(param_list: Iterable[Union[Parameter, EndOfPduField]]) -> str:
-    result = ""
+def parameter_info(param_list: Iterable[Parameter], quoted_names: bool = False) -> str:
+    q = "'" if quoted_names else ""
+    of = StringIO()
     for param in param_list:
         if isinstance(param, CodedConstParameter):
-            result += f"{param.short_name} : const = {param._coded_value_str}\n"
+            of.write(f"{q}{param.short_name}{q}: const = {param._coded_value_str}\n")
             continue
         elif isinstance(param, MatchingRequestParameter):
-            result += f"{param.short_name} : <matches request>\n"
+            of.write(f"{q}{param.short_name}{q}: <matches request>\n")
+            continue
+        elif isinstance(param, NrcConstParameter):
+            of.write(f"{q}{param.short_name}{q}: const; choices = {param.coded_values}\n")
             continue
         elif isinstance(param, ReservedParameter):
-            result += f"{param.short_name} : <reserved>\n"
+            of.write(f"{q}{param.short_name}{q}: <reserved>\n")
+            continue
+        elif isinstance(param, TableKeyParameter):
+            of.write(
+                f"{q}{param.short_name}{q}: <optional> table key; table = '{param.table.short_name}'; choices:\n"
+            )
+            for tr in param.table.table_rows:
+                of.write(f"  '{tr.short_name}',\n")
+
+            continue
+        elif isinstance(param, TableStructParameter):
+            of.write(
+                f"{q}{param.short_name}{q}: table struct; key = '{param.table_key.short_name}'; choices:\n"
+            )
+            for tr in param.table_key.table.table_rows:
+                of.write(f"  ('{tr.short_name}',\n")
+                of.write(f"   {{\n")
+                of.write(
+                    textwrap.indent(
+                        parameter_info(odxrequire(tr.structure).parameters, True), "    "))
+                of.write(f"   }}),\n")
+
             continue
         elif not isinstance(param, ParameterWithDOP):
-            result += f"{param.short_name} : <unhandled parameter type>\n"
+            of.write(
+                f"{q}{param.short_name}{q}: <unhandled parameter type '{type(param).__name__}'>\n")
             continue
 
         dop = param.dop
-
         if isinstance(dop, EndOfPduField):
-            result += f"{param.short_name} : <optional> list({{\n"
-            tmp = parameter_info(dop.structure.parameters).strip()
-            tmp = re.sub("^", "  ", tmp)
-            result += tmp + "\n"
-            result += f"}})\n"
+            of.write(f"{q}{param.short_name}{q}: list({{\n")
+            of.write(textwrap.indent(parameter_info(dop.structure.parameters, True), "  "))
+            of.write(f"}})\n")
+            continue
+        elif isinstance(dop, StaticField):
+            of.write(f"{q}{param.short_name}{q}: length={dop.fixed_number_of_items}; list({{\n")
+            of.write(textwrap.indent(parameter_info(dop.structure.parameters, True), "  "))
+            of.write(f"}})\n")
+            continue
+        elif isinstance(dop, DynamicLengthField):
+            of.write(f"{q}{param.short_name}{q}: list({{\n")
+            of.write(textwrap.indent(parameter_info(dop.structure.parameters, True), "  "))
+            of.write(f"}})\n")
+            continue
+        elif isinstance(dop, ParamLengthInfoType):
+            of.write(f"{q}{param.short_name}{q}: ")
+            of.write("<optional> ")
+            of.write(f"int; length_key='{dop.length_key.short_name}'\n")
+            continue
+        elif isinstance(dop, DtcDop):
+            of.write(f"{q}{param.short_name}{q}: ")
+            of.write(f"DTC; choices:\n")
+            for dtc in dop.dtcs:
+                if dtc.display_trouble_code is not None:
+                    dtc_desc = dtc.text and f"; \"{dtc.text}\""
+                    of.write(
+                        f"  '{dtc.display_trouble_code}' (0x{dtc.trouble_code:06x}{dtc_desc})\n")
+                else:
+                    dtc_desc = dtc.text and f" (\"{dtc.text}\")"
+                    of.write(f"  0x{dtc.trouble_code:06x}{dtc_desc}\n")
+            continue
+        elif isinstance(dop, Multiplexer):
+            of.write(f"{q}{param.short_name}{q}: ")
+            if dop.default_case is not None:
+                of.write(f"<optional>")
+            of.write(f"multiplexer; choices:\n")
+            for mux_case in dop.cases:
+                of.write(f"  ({repr(mux_case.short_name)}, {{\n")
+                of.write(
+                    textwrap.indent(parameter_info(mux_case.structure.parameters, True), "    "))
+                of.write(f"   }})\n")
             continue
 
-        result += f"{param.short_name}"
+        of.write(f"{q}{param.short_name}{q}")
 
         if dop is None:
-            result += ": <no DOP>\n"
+            of.write(": <no DOP>\n")
             continue
         elif not isinstance(dop, DataObjectProperty):
-            result += ": <unhandled DOP>\n"
+            of.write(f": <unhandled DOP '{type(dop).__name__}'>\n")
             continue
 
         if (cm := dop.compu_method) is None:
-            result += ": <no compu method>\n"
+            of.write(": <no compu method>\n")
             continue
 
         if isinstance(cm, TexttableCompuMethod):
-            result += f": enum; choices:\n"
+            of.write(f": enum; choices:\n")
             for scale in cm.internal_to_phys:
-                result += f"  '{str(scale.compu_const)}'\n"
+                val_str = ""
+                if scale.lower_limit is not None:
+                    val_str = f"({repr(scale.lower_limit.value)})"
+                of.write(f"  {repr(scale.compu_const)}{val_str}\n")
 
         elif isinstance(cm, IdenticalCompuMethod):
             bdt = dop.physical_type.base_data_type
             if bdt in (DataType.A_UTF8STRING, DataType.A_UNICODE2STRING, DataType.A_ASCIISTRING):
-                result += f": str"
-            elif bdt in (DataType.A_BYTEFIELD,):
-                result += f": bytes"
+                of.write(f": str")
+            elif bdt == DataType.A_BYTEFIELD:
+                of.write(f": bytes")
             elif bdt.name.startswith("A_FLOAT"):
-                result += f": float"
+                of.write(f": float")
             elif bdt.name.startswith("A_UINT"):
-                result += f": uint"
+                of.write(f": uint")
             elif bdt.name.startswith("A_INT"):
-                result += f": int"
+                of.write(f": int")
             else:
-                result += f": <unknown type>"
-
-            if (bl := dop.get_static_bit_length()) is not None:
-                result += f"{bl}"
+                of.write(f": <unknown type {{ bdt.name }}>")
 
-            result += "\n"
+            of.write("\n")
 
         elif isinstance(cm, LinearCompuMethod):
-            result += f": float\n"
+            bdt = dop.physical_type.base_data_type
+            if bdt in (DataType.A_UTF8STRING, DataType.A_UNICODE2STRING, DataType.A_ASCIISTRING):
+                of.write(f": str")
+            elif bdt in (DataType.A_BYTEFIELD,):
+                of.write(f": bytes")
+            elif bdt.name.startswith("A_FLOAT"):
+                of.write(f": float")
+            elif bdt.name.startswith("A_UINT"):
+                of.write(f": uint")
+            elif bdt.name.startswith("A_INT"):
+                of.write(f": int")
+            else:
+                of.write(f": <unknown type>")
+
             ll = cm.physical_lower_limit
             ul = cm.physical_upper_limit
-            if ll is None:
-                ll_str = "(inf"
+            if ll is None or ll.interval_type == IntervalType.INFINITE:
+                ll_str = "(-inf"
             else:
-                ll_delim = '[' if ll.interval_type == IntervalType.CLOSED else '('
+                ll_delim = '(' if ll.interval_type == IntervalType.OPEN else '['
                 ll_str = f"{ll_delim}{ll._value!r}"
 
-            if ul is None:
+            if ul is None or ul.interval_type == IntervalType.INFINITE:
                 ul_str = "inf)"
             else:
-                ul_delim = ']' if ul.interval_type == IntervalType.CLOSED else ')'
+                ul_delim = ')' if ul.interval_type == IntervalType.OPEN else ']'
                 ul_str = f"{ul._value!r}{ul_delim}"
-            result += f" range: {ll_str}, {ul_str}\n"
+            of.write(f"; range: {ll_str}, {ul_str}")
 
             unit = dop.unit
             unit_str = unit.display_name if unit is not None else None
             if unit_str is not None:
-                result += f" unit: {unit_str}\n"
+                of.write(f"; unit: {unit_str}")
+
+            of.write("\n")
 
-    return result
+    return of.getvalue()

odxtools/parameters/codedconstparameter.py

@@ -10,9 +10,9 @@ 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, odxrequire
+from ..exceptions import DecodeError, EncodeError, odxraise, odxrequire
 from ..odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
-from ..odxtypes import AtomicOdxType, DataType
+from ..odxtypes import AtomicOdxType, DataType, ParameterValue
 from ..utils import dataclass_fields_asdict
 from .parameter import Parameter, ParameterType
 
@@ -81,20 +81,23 @@ class CodedConstParameter(Parameter):
         return False
 
     @override
-    def get_coded_value_as_bytes(self, encode_state: EncodeState) -> bytes:
-        if (self.short_name in encode_state.parameter_values and
-                encode_state.parameter_values[self.short_name] != self.coded_value):
-            raise TypeError(f"The parameter '{self.short_name}' is constant {self._coded_value_str}"
-                            " and thus can not be changed.")
-        bit_position_int = self.bit_position if self.bit_position is not None else 0
-        return self.diag_coded_type.convert_internal_to_bytes(
-            self.coded_value, encode_state=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.coded_value:
+            odxraise(
+                f"Value for constant parameter `{self.short_name}` name can "
+                f"only be specified as {self.coded_value!r} (is: {physical_value!r})", EncodeError)
+
+        internal_value = self.coded_value
+
+        self.diag_coded_type.encode_into_pdu(
+            internal_value=internal_value, encode_state=encode_state)
 
     @override
     def _decode_positioned_from_pdu(self, decode_state: DecodeState) -> AtomicOdxType:
         coded_val = self.diag_coded_type.decode_from_pdu(decode_state)
 
-        # Check if the coded value in the message is correct.
+        # Check if the coded value contained by the message is correct.
         if self.coded_value != coded_val:
             warnings.warn(
                 f"Coded constant parameter does not match! "

odxtools/parameters/dynamicparameter.py

@@ -1,6 +1,6 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import List
+from typing import List, Optional
 from xml.etree import ElementTree
 
 from typing_extensions import override
@@ -41,9 +41,10 @@ class DynamicParameter(Parameter):
         raise NotImplementedError(".is_settable for a DynamicParameter")
 
     @override
-    def get_coded_value_as_bytes(self, encode_state: EncodeState) -> bytes:
-        raise NotImplementedError("Encoding a DynamicParameter is not implemented yet.")
+    def _encode_positioned_into_pdu(self, physical_value: Optional[ParameterValue],
+                                    encode_state: EncodeState) -> None:
+        raise NotImplementedError("Encoding DynamicParameter is not implemented yet.")
 
     @override
     def _decode_positioned_from_pdu(self, decode_state: DecodeState) -> ParameterValue:
-        raise NotImplementedError("Decoding a DynamicParameter is not implemented yet.")
+        raise NotImplementedError("Decoding DynamicParameter is not implemented yet.")