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

odxtools/basicstructure.py

@@ -4,6 +4,8 @@ from dataclasses import dataclass
 from typing import TYPE_CHECKING, Any, Dict, List, Optional, cast
 from xml.etree import ElementTree
 
+from typing_extensions import override
+
 from .complexdop import ComplexDop
 from .dataobjectproperty import DataObjectProperty
 from .decodestate import DecodeState
@@ -21,6 +23,7 @@ from .parameters.parameter import Parameter
 from .parameters.parameterwithdop import ParameterWithDOP
 from .parameters.physicalconstantparameter import PhysicalConstantParameter
 from .parameters.tablekeyparameter import TableKeyParameter
+from .parameters.tablestructparameter import TableStructParameter
 from .utils import dataclass_fields_asdict
 
 if TYPE_CHECKING:
@@ -54,32 +57,29 @@ class BasicStructure(ComplexDop):
             return 8 * self.byte_size
 
         cursor = 0
-        length = 0
+        byte_length = 0
         for param in self.parameters:
             param_bit_length = param.get_static_bit_length()
             if param_bit_length is None:
                 # We were not able to calculate a static bit length
                 return None
             elif param.byte_position is not None:
-                bit_pos = param.bit_position or 0
-                byte_pos = param.byte_position or 0
-                cursor = byte_pos * 8 + bit_pos
+                cursor = param.byte_position
 
-            cursor += param_bit_length
-            length = max(length, cursor)
+            cursor += ((param.bit_position or 0) + param_bit_length + 7) // 8
+            byte_length = max(byte_length, cursor)
 
         # Round up to account for padding bits (all structures are
         # byte aligned)
-        return ((length + 7) // 8) * 8
+        return byte_length * 8
 
     def coded_const_prefix(self, request_prefix: bytes = b'') -> bytes:
-        prefix = b''
-        encode_state = EncodeState(
-            bytearray(prefix), parameter_values={}, triggering_request=request_prefix)
+        encode_state = EncodeState(coded_message=bytearray(), triggering_request=request_prefix)
+
         for param in self.parameters:
-            if isinstance(param, (CodedConstParameter, NrcConstParameter, MatchingRequestParameter,
-                                  PhysicalConstantParameter)):
-                encode_state.coded_message = bytearray(param.encode_into_pdu(encode_state))
+            if (isinstance(param, MatchingRequestParameter) and param.request_byte_position < len(request_prefix)) or \
+                isinstance(param, (CodedConstParameter, NrcConstParameter, PhysicalConstantParameter)):
+                param.encode_into_pdu(physical_value=None, encode_state=encode_state)
             else:
                 break
         return encode_state.coded_message
@@ -116,58 +116,101 @@ class BasicStructure(ComplexDop):
 
         print(parameter_info(self.free_parameters), end="")
 
-    def convert_physical_to_internal(self,
-                                     param_value: ParameterValue,
-                                     triggering_coded_request: Optional[bytes],
-                                     is_end_of_pdu: bool = True) -> bytes:
+    def _validate_coded_message_size(self, coded_byte_len: int) -> None:
+
+        if self.byte_size is not None:
+            # We definitely broke something if we didn't respect the explicit byte_size
+            if self.byte_size != coded_byte_len:
+                warnings.warn(
+                    "Verification of coded message failed: Incorrect size.",
+                    OdxWarning,
+                    stacklevel=1)
+
+            return
+
+        bit_length = self.get_static_bit_length()
 
-        if not isinstance(param_value, dict):
-            raise EncodeError(
+        if bit_length is None:
+            # Nothing to check
+            return
+
+        if coded_byte_len * 8 != bit_length:
+            # We may have broke something
+            # but it could be that bit_length was mis calculated and not the actual bytes are wrong
+            # Could happen with overlapping parameters and parameters with gaps
+            warnings.warn(
+                "Verification of coded message possibly failed: Size may be incorrect.",
+                OdxWarning,
+                stacklevel=1)
+
+    @override
+    def encode_into_pdu(self, physical_value: Optional[ParameterValue],
+                        encode_state: EncodeState) -> None:
+        if not isinstance(physical_value, dict):
+            odxraise(
                 f"Expected a dictionary for the values of structure {self.short_name}, "
-                f"got {type(param_value)}")
+                f"got {type(physical_value).__name__}", EncodeError)
+        elif encode_state.cursor_bit_position != 0:
+            odxraise(
+                f"Structures must be byte aligned, but "
+                f"{self.short_name} requested to be at bit position "
+                f"{encode_state.cursor_bit_position}", EncodeError)
+            encode_state.bit_position = 0
+
+        orig_cursor = encode_state.cursor_byte_position
+        orig_origin = encode_state.origin_byte_position
+        encode_state.origin_byte_position = encode_state.cursor_byte_position
+
+        orig_is_end_of_pdu = encode_state.is_end_of_pdu
+        encode_state.is_end_of_pdu = False
 
         # in strict mode, ensure that no values for unknown parameters are specified.
         if strict_mode:
-            param_names = [param.short_name for param in self.parameters]
-            for param_key in param_value:
-                if param_key not in param_names:
-                    odxraise(f"Value for unknown parameter '{param_key}' specified")
-
-        encode_state = EncodeState(
-            bytearray(),
-            dict(param_value),
-            triggering_request=triggering_coded_request,
-            is_end_of_pdu=False,
-        )
+            param_names = {param.short_name for param in self.parameters}
+            for param_value_name in physical_value:
+                if param_value_name not in param_names:
+                    odxraise(f"Value for unknown parameter '{param_value_name}' specified "
+                             f"for structure {self.short_name}")
 
         for param in self.parameters:
-            if param == self.parameters[-1]:
-                # The last parameter is at the end of the PDU if the
-                # structure itself is at the end of the PDU. TODO:
-                # This assumes that the last parameter specified in
-                # the ODX is located last in the PDU...
-                encode_state.is_end_of_pdu = is_end_of_pdu
-
-            if isinstance(
-                    param,
-                (LengthKeyParameter, TableKeyParameter)) and param.short_name in param_value:
-                # This is a hack to always encode a dummy value for
-                # length- and table keys. since these can be specified
+            if id(param) == id(self.parameters[-1]):
+                # The last parameter of the structure is at the end of
+                # the PDU if the structure itself is at the end of the
+                # PDU. TODO: This assumes that the last parameter
+                # specified in the ODX is located last in the PDU...
+                encode_state.is_end_of_pdu = orig_is_end_of_pdu
+
+            if isinstance(param, (LengthKeyParameter, TableKeyParameter)):
+                # At this point, we encode a placeholder value for length-
+                # and table keys, since these can be specified
                 # implicitly (i.e., by means of parameters that use
-                # these keys), to avoid getting an "overlapping
+                # these keys). To avoid getting an "overlapping
                 # parameter" warning, we must encode a value of zero
                 # into the PDU here and add the real value of the
-                # parameter in a post processing step.
-                tmp = encode_state.parameter_values.pop(param.short_name)
-                encode_state.coded_message = bytearray(param.encode_into_pdu(encode_state))
-                encode_state.parameter_values[param.short_name] = tmp
+                # parameter in a post-processing step.
+                param.encode_placeholder_into_pdu(
+                    physical_value=physical_value.get(param.short_name), encode_state=encode_state)
+
                 continue
 
-            encode_state.coded_message = bytearray(param.encode_into_pdu(encode_state))
+            if param.is_required and param.short_name not in physical_value:
+                odxraise(f"No value for required parameter {param.short_name} specified",
+                         EncodeError)
 
-        if self.byte_size is not None and len(encode_state.coded_message) < self.byte_size:
-            # Padding bytes needed
-            encode_state.coded_message = encode_state.coded_message.ljust(self.byte_size, b"\0")
+            param.encode_into_pdu(
+                physical_value=physical_value.get(param.short_name), encode_state=encode_state)
+
+        encode_state.is_end_of_pdu = False
+        if self.byte_size is not None:
+            actual_len = encode_state.cursor_byte_position - encode_state.origin_byte_position
+            if actual_len < self.byte_size:
+                # Padding bytes needed. We add an empty object at the
+                # position directly after the structure and let
+                # EncodeState add the padding as needed.
+                encode_state.cursor_byte_position = encode_state.origin_byte_position + self.byte_size
+                # Padding bytes needed. these count as "used".
+                encode_state.coded_message += b"\x00" * (self.byte_size - actual_len)
+                encode_state.used_mask += b"\xff" * (self.byte_size - actual_len)
 
         # encode the length- and table keys. This cannot be done above
         # because we allow these to be defined implicitly (i.e. they
@@ -177,56 +220,17 @@ class BasicStructure(ComplexDop):
                 # the current parameter is neither a length- nor a table key
                 continue
 
-            # Encode the key parameter into the message
-            encode_state.coded_message = bytearray(param.encode_into_pdu(encode_state))
+            # Encode the value of the key parameter into the message
+            param.encode_value_into_pdu(encode_state=encode_state)
 
         # Assert that length is as expected
-        self._validate_coded_message(encode_state.coded_message)
-
-        return bytearray(encode_state.coded_message)
-
-    def _validate_coded_message(self, coded_message: bytes) -> None:
-
-        if self.byte_size is not None:
-            # We definitely broke something if we didn't respect the explicit byte_size
-            odxassert(
-                len(coded_message) == self.byte_size,
-                "Verification of coded message {coded_message.hex()} failed: Incorrect size.")
-            # No need to check further
-            return
-
-        bit_length = self.get_static_bit_length()
-
-        if bit_length is None:
-            # Nothing to check
-            return
+        self._validate_coded_message_size(encode_state.cursor_byte_position -
+                                          encode_state.origin_byte_position)
 
-        if len(coded_message) * 8 != bit_length:
-            # We may have broke something
-            # but it could be that bit_length was mis calculated and not the actual bytes are wrong
-            # Could happen with overlapping parameters and parameters with gaps
-            warnings.warn(
-                f"Verification of coded message '{coded_message.hex()}' possibly failed: Size may be incorrect.",
-                OdxWarning,
-                stacklevel=1)
-
-    def convert_physical_to_bytes(self,
-                                  physical_value: ParameterValue,
-                                  encode_state: EncodeState,
-                                  bit_position: int = 0) -> bytes:
-        if not isinstance(physical_value, dict):
-            raise EncodeError(
-                f"Expected a dictionary for the values of structure {self.short_name}, "
-                f"got {type(physical_value)}")
-        if bit_position != 0:
-            raise EncodeError("Structures must be aligned, i.e. bit_position=0, but "
-                              f"{self.short_name} was passed the bit position {bit_position}")
-        return self.convert_physical_to_internal(
-            physical_value,
-            triggering_coded_request=encode_state.triggering_request,
-            is_end_of_pdu=encode_state.is_end_of_pdu,
-        )
+        encode_state.origin_byte_position = orig_origin
+        encode_state.cursor_byte_position = max(orig_cursor, encode_state.cursor_byte_position)
 
+    @override
     def decode_from_pdu(self, decode_state: DecodeState) -> ParameterValue:
         # move the origin since positions specified by sub-parameters of
         # structures are relative to the beginning of the structure object.
@@ -244,19 +248,6 @@ class BasicStructure(ComplexDop):
 
         return result
 
-    def encode(self, coded_request: Optional[bytes] = None, **params: ParameterValue) -> bytes:
-        """
-        Composes an UDS message as bytes for this service.
-        Parameters:
-        ----------
-        coded_request: bytes
-            coded request (only needed when encoding a response)
-        params: dict
-            Parameters of the RPC as mapping from SHORT-NAME of the parameter to the value
-        """
-        return self.convert_physical_to_internal(
-            params, triggering_coded_request=coded_request, is_end_of_pdu=True)
-
     def decode(self, message: bytes) -> ParameterValueDict:
         decode_state = DecodeState(coded_message=message)
         param_values = self.decode_from_pdu(decode_state)
@@ -316,4 +307,7 @@ class BasicStructure(ComplexDop):
         super()._resolve_snrefs(diag_layer)
 
         for param in self.parameters:
-            param._resolve_snrefs(diag_layer)
+            if isinstance(param, TableStructParameter):
+                param._table_struct_resolve_snrefs(diag_layer, param_list=self.parameters)
+            else:
+                param._resolve_snrefs(diag_layer)

odxtools/compumethods/createanycompumethod.py

@@ -137,7 +137,7 @@ def create_any_compu_method_from_et(et_element: ElementTree.Element,
                     scale_elem, doc_frags, internal_type=internal_type,
                     physical_type=physical_type))
         compu_default_value = create_compu_default_value(
-            et_element.find("COMPU-DEFAULT-VALUE"), doc_frags, **kwargs)
+            et_element.find("COMPU-INTERNAL-TO-PHYS/COMPU-DEFAULT-VALUE"), doc_frags, **kwargs)
 
         return TexttableCompuMethod(
             internal_to_phys=internal_to_phys,

odxtools/dataobjectproperty.py

@@ -120,10 +120,7 @@ class DataObjectProperty(DopBase):
 
         return self.compu_method.convert_physical_to_internal(physical_value)
 
-    def convert_physical_to_bytes(self,
-                                  physical_value: Any,
-                                  encode_state: EncodeState,
-                                  bit_position: int = 0) -> bytes:
+    def encode_into_pdu(self, physical_value: ParameterValue, encode_state: EncodeState) -> None:
         """
         Convert a physical representation of a parameter to a string bytes that can be send over the wire
         """
@@ -132,9 +129,8 @@ class DataObjectProperty(DopBase):
                 f"The value {repr(physical_value)} of type {type(physical_value).__name__}"
                 f" is not a valid.")
 
-        internal_val = self.convert_physical_to_internal(physical_value)
-        return self.diag_coded_type.convert_internal_to_bytes(
-            internal_val, encode_state, bit_position=bit_position)
+        internal_value = self.convert_physical_to_internal(physical_value)
+        self.diag_coded_type.encode_into_pdu(internal_value, encode_state)
 
     def decode_from_pdu(self, decode_state: DecodeState) -> ParameterValue:
         """

odxtools/decodestate.py

@@ -15,18 +15,6 @@ except ImportError:
 if TYPE_CHECKING:
     from .tablerow import TableRow
 
-# format specifiers for the data type using the bitstruct module
-ODX_TYPE_TO_FORMAT_LETTER = {
-    DataType.A_INT32: "s",
-    DataType.A_UINT32: "u",
-    DataType.A_FLOAT32: "f",
-    DataType.A_FLOAT64: "f",
-    DataType.A_BYTEFIELD: "r",
-    DataType.A_UNICODE2STRING: "r",  # UTF-16 strings must be converted explicitly
-    DataType.A_ASCIISTRING: "r",
-    DataType.A_UTF8STRING: "r",
-}
-
 
 @dataclass
 class DecodeState:
@@ -94,7 +82,7 @@ class DecodeState:
 
         padding = (8 - (bit_length + self.cursor_bit_position) % 8) % 8
         internal_value, = bitstruct.unpack_from(
-            f"{ODX_TYPE_TO_FORMAT_LETTER[base_data_type]}{bit_length}",
+            f"{base_data_type.bitstruct_format_letter}{bit_length}",
             extracted_bytes,
             offset=padding)
 

odxtools/diagcodedtype.py

@@ -1,19 +1,14 @@
 # SPDX-License-Identifier: MIT
 import abc
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Dict, Literal, Optional, Union, cast
+from typing import TYPE_CHECKING, Any, Dict, Literal, Optional, Union
 
-from .decodestate import ODX_TYPE_TO_FORMAT_LETTER, DecodeState
+from .decodestate import DecodeState
 from .encodestate import EncodeState
-from .exceptions import EncodeError, odxassert, odxraise
+from .exceptions import odxassert, odxraise
 from .odxlink import OdxLinkDatabase, OdxLinkId
 from .odxtypes import AtomicOdxType, DataType
 
-try:
-    import bitstruct.c as bitstruct
-except ImportError:
-    import bitstruct
-
 if TYPE_CHECKING:
     from .diaglayer import DiagLayer
 
@@ -56,88 +51,6 @@ class DiagCodedType(abc.ABC):
     def is_highlow_byte_order(self) -> bool:
         return self.is_highlow_byte_order_raw in [None, True]
 
-    @staticmethod
-    def _encode_internal_value(
-        internal_value: AtomicOdxType,
-        bit_position: int,
-        bit_length: int,
-        base_data_type: DataType,
-        is_highlow_byte_order: bool,
-    ) -> bytes:
-        """Convert the internal_value to bytes."""
-        # Check that bytes and strings actually fit into the bit length
-        if base_data_type == DataType.A_BYTEFIELD:
-            if isinstance(internal_value, bytearray):
-                internal_value = bytes(internal_value)
-            if not isinstance(internal_value, bytes):
-                odxraise()
-            if 8 * len(internal_value) > bit_length:
-                raise EncodeError(f"The bytefield {internal_value.hex()} is too large "
-                                  f"({len(internal_value)} bytes)."
-                                  f" The maximum length is {bit_length//8}.")
-        if base_data_type == DataType.A_ASCIISTRING:
-            if not isinstance(internal_value, str):
-                odxraise()
-
-            # The spec says ASCII, meaning only byte values 0-127.
-            # But in practice, vendors use iso-8859-1, aka latin-1
-            # reason being iso-8859-1 never fails since it has a valid
-            # character mapping for every possible byte sequence.
-            internal_value = internal_value.encode("iso-8859-1")
-
-            if 8 * len(internal_value) > bit_length:
-                raise EncodeError(f"The string {repr(internal_value)} is too large."
-                                  f" The maximum number of characters is {bit_length//8}.")
-        elif base_data_type == DataType.A_UTF8STRING:
-            if not isinstance(internal_value, str):
-                odxraise()
-
-            internal_value = internal_value.encode("utf-8")
-
-            if 8 * len(internal_value) > bit_length:
-                raise EncodeError(f"The string {repr(internal_value)} is too large."
-                                  f" The maximum number of bytes is {bit_length//8}.")
-
-        elif base_data_type == DataType.A_UNICODE2STRING:
-            if not isinstance(internal_value, str):
-                odxraise()
-
-            text_encoding = "utf-16-be" if is_highlow_byte_order else "utf-16-le"
-            internal_value = internal_value.encode(text_encoding)
-
-            if 8 * len(internal_value) > bit_length:
-                raise EncodeError(f"The string {repr(internal_value)} is too large."
-                                  f" The maximum number of characters is {bit_length//16}.")
-
-        # If the bit length is zero, return empty bytes
-        if bit_length == 0:
-            if (base_data_type.value in [
-                    DataType.A_INT32, DataType.A_UINT32, DataType.A_FLOAT32, DataType.A_FLOAT64
-            ] and base_data_type.value != 0):
-                raise EncodeError(
-                    f"The number {repr(internal_value)} cannot be encoded into {bit_length} bits.")
-            return b''
-
-        char = ODX_TYPE_TO_FORMAT_LETTER[base_data_type]
-        padding = (8 - ((bit_length + bit_position) % 8)) % 8
-        odxassert((0 <= padding and padding < 8 and (padding + bit_length + bit_position) % 8 == 0),
-                  f"Incorrect padding {padding}")
-        left_pad = f"p{padding}" if padding > 0 else ""
-
-        # actually encode the value
-        coded = bitstruct.pack(f"{left_pad}{char}{bit_length}", internal_value)
-
-        # apply byte order for numeric objects
-        if not is_highlow_byte_order and base_data_type in [
-                DataType.A_INT32,
-                DataType.A_UINT32,
-                DataType.A_FLOAT32,
-                DataType.A_FLOAT64,
-        ]:
-            coded = coded[::-1]
-
-        return cast(bytes, coded)
-
     def _minimal_byte_length_of(self, internal_value: Union[bytes, str]) -> int:
         """Helper method to get the minimal byte length.
         (needed for LeadingLength- and MinMaxLengthType)
@@ -160,11 +73,10 @@ class DiagCodedType(abc.ABC):
             odxassert(
                 byte_length % 2 == 0, f"The bit length of A_UNICODE2STRING must"
                 f" be a multiple of 16 but is {8*byte_length}")
+
         return byte_length
 
-    @abc.abstractmethod
-    def convert_internal_to_bytes(self, internal_value: AtomicOdxType, encode_state: EncodeState,
-                                  bit_position: int) -> bytes:
+    def encode_into_pdu(self, internal_value: AtomicOdxType, encode_state: EncodeState) -> None:
         """Encode the internal value.
 
         Parameters
@@ -177,9 +89,9 @@ class DiagCodedType(abc.ABC):
             mapping from ID (of the length key) to bit length
             (only needed for ParamLengthInfoType)
         """
-        pass
+        raise NotImplementedError(
+            f".encode_into_pdu() is not implemented by the class {type(self).__name__}")
 
-    @abc.abstractmethod
     def decode_from_pdu(self, decode_state: DecodeState) -> AtomicOdxType:
         """Decode the parameter value from the coded message.
 
@@ -195,4 +107,5 @@ class DiagCodedType(abc.ABC):
         int
             the next byte position after the extracted parameter
         """
-        pass
+        raise NotImplementedError(
+            f".decode_from_pdu() is not implemented by the class {type(self).__name__}")

odxtools/diaglayer.py

@@ -1,6 +1,7 @@
 # SPDX-License-Identifier: MIT
 import re
 import warnings
+from copy import copy
 from dataclasses import dataclass
 from functools import cached_property
 from itertools import chain
@@ -76,6 +77,50 @@ class DiagLayer:
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
         """Recursively resolve all references."""
 
+        # deal with the import references: these basically extend the
+        # pool of objects that are referenceable without having to
+        # explicitly specify the DOCREF attribute in the
+        # reference. This mechanism can thus be seen as a kind of
+        # "poor man's inheritance".
+        if self.import_refs:
+            imported_links: Dict[OdxLinkId, Any] = {}
+            for import_ref in self.import_refs:
+                imported_dl = odxlinks.resolve(import_ref, DiagLayer)
+
+                odxassert(
+                    imported_dl.variant_type == DiagLayerType.ECU_SHARED_DATA,
+                    f"Tried to import references from diagnostic layer "
+                    f"'{imported_dl.short_name}' of type {imported_dl.variant_type.value}. "
+                    f"Only ECU-SHARED-DATA layers may be referenced using the "
+                    f"IMPORT-REF mechanism")
+
+                # TODO: ensure that the imported diagnostic layer has
+                # not been referenced in any PARENT-REF of the current
+                # layer or any of its parents.
+
+                # TODO: detect and complain about cyclic IMPORT-REFs
+
+                # TODO (?): detect conflicts with locally-defined
+                # objects
+
+                imported_dl_links = imported_dl._build_odxlinks()
+                for link_id, obj in imported_dl_links.items():
+                    # the imported objects shall behave as if they
+                    # were defined by the importing layer. IOW, they
+                    # must be visible in the same document fragments.
+                    link_id = OdxLinkId(link_id.local_id, self.odx_id.doc_fragments)
+                    imported_links[link_id] = obj
+
+            # We need to copy the odxlink database here since this
+            # function must not modify its argument because the
+            # imported references only apply within this specific
+            # diagnostic layer
+            extended_odxlinks = copy(odxlinks)
+            extended_odxlinks.update(imported_links)
+
+            self.diag_layer_raw._resolve_odxlinks(extended_odxlinks)
+            return
+
         self.diag_layer_raw._resolve_odxlinks(odxlinks)
 
     def _finalize_init(self, odxlinks: OdxLinkDatabase) -> None:

odxtools/diagservice.py

@@ -215,13 +215,9 @@ class DiagService(DiagComm):
             coding_object=coding_object,
             param_dict=param_dict)
 
-    def encode_request(self, **params: ParameterValue) -> bytes:
+    def encode_request(self, **kwargs: ParameterValue) -> bytes:
         """
-        Composes an UDS request as list of bytes for this service.
-        Parameters:
-        ----------
-        params: dict
-            Parameters of the RPC as mapping from SHORT-NAME of the parameter to the physical value
+        Composes an UDS request an array of bytes for this service.
         """
         # make sure that all parameters which are required for
         # encoding are specified (parameters which have a default are
@@ -230,31 +226,31 @@ class DiagService(DiagComm):
             return b''
 
         missing_params = {x.short_name
-                          for x in self.request.required_parameters}.difference(params.keys())
+                          for x in self.request.required_parameters}.difference(kwargs.keys())
         odxassert(
             len(missing_params) == 0, f"The parameters {missing_params} are required but missing!")
 
         # make sure that no unknown parameters are specified
         rq_all_param_names = {x.short_name for x in self.request.parameters}
         odxassert(
-            set(params.keys()).issubset(rq_all_param_names),
-            f"Unknown parameters specified for encoding: {params.keys()}, "
+            set(kwargs.keys()).issubset(rq_all_param_names),
+            f"Unknown parameters specified for encoding: {kwargs.keys()}, "
             f"known parameters are: {rq_all_param_names}")
-        return self.request.encode(coded_request=None, **params)
+        return self.request.encode(**kwargs)
 
     def encode_positive_response(self,
                                  coded_request: bytes,
                                  response_index: int = 0,
-                                 **params: ParameterValue) -> bytes:
+                                 **kwargs: ParameterValue) -> bytes:
         # TODO: Should the user decide the positive response or what are the differences?
-        return self.positive_responses[response_index].encode(coded_request, **params)
+        return self.positive_responses[response_index].encode(coded_request, **kwargs)
 
     def encode_negative_response(self,
                                  coded_request: bytes,
                                  response_index: int = 0,
-                                 **params: ParameterValue) -> bytes:
-        return self.negative_responses[response_index].encode(coded_request, **params)
+                                 **kwargs: ParameterValue) -> bytes:
+        return self.negative_responses[response_index].encode(coded_request, **kwargs)
 
-    def __call__(self, **params: ParameterValue) -> bytes:
+    def __call__(self, **kwargs: ParameterValue) -> bytes:
         """Encode a request."""
-        return self.encode_request(**params)
+        return self.encode_request(**kwargs)

odxtools/dopbase.py

@@ -21,7 +21,8 @@ if TYPE_CHECKING:
 class DopBase(IdentifiableElement):
     """Base class for all DOPs.
 
-    Any class that a parameter can reference via a DOP-REF should inherit from this class.
+    Any class that a parameter can reference via a DOP-REF should
+    inherit from this class.
     """
 
     admin_data: Optional[AdminData]
@@ -60,15 +61,11 @@ class DopBase(IdentifiableElement):
         return None
 
     def is_valid_physical_value(self, physical_value: ParameterValue) -> bool:
-        """Determine if a phyical value can be handled by the DOP
-        """
+        """Determine if a phyical value can be handled by the DOP"""
         raise NotImplementedError
 
-    def convert_physical_to_bytes(self,
-                                  physical_value: ParameterValue,
-                                  encode_state: EncodeState,
-                                  bit_position: int = 0) -> bytes:
-        """Convert the physical value into bytes."""
+    def encode_into_pdu(self, physical_value: ParameterValue, encode_state: EncodeState) -> None:
+        """Convert the physical value to bytes and emplace them into a PDU."""
         raise NotImplementedError
 
     def decode_from_pdu(self, decode_state: DecodeState) -> ParameterValue: