odxtools 6.4.2__py3-none-any.whl → 6.5.0__py3-none-any.whl

odxtools/cli/decode.py

@@ -84,7 +84,7 @@ def add_subparser(subparsers: "argparse._SubParsersAction") -> None:
             "  For more information use:",
             "    odxtools decode -h",
         ]),
-        help="Find & print service by hex-data. Can also decode the hex-data to into their named parameters.",
+        help="Find & print service by hex-data. Can also decode the hex-data to its named parameters.",
         formatter_class=argparse.RawTextHelpFormatter,
     )
     _parser_utils.add_pdx_argument(parser)

odxtools/cli/find.py

@@ -26,7 +26,8 @@ def print_summary(odxdb: Database,
                   service_names: List[str],
                   ecu_variants: Optional[List[str]] = None,
                   allow_unknown_bit_lengths: bool = False,
-                  print_params: bool = False) -> None:
+                  print_params: bool = False,
+                  plumbing_output: bool = False) -> None:
     ecu_names = ecu_variants if ecu_variants else [ecu.short_name for ecu in odxdb.ecus]
     service_db: Dict[str, DiagService] = {}
     service_ecus: Dict[str, List[str]] = {}
@@ -60,7 +61,7 @@ def print_summary(odxdb: Database,
                 print_pre_condition_states=True,
                 print_state_transitions=True,
                 print_audiences=True,
-            )
+                plumbing_output=plumbing_output)
         elif isinstance(service, SingleEcuJob):
             print(f"SingleEcuJob: {service.odx_id}")
         else:
@@ -79,7 +80,7 @@ def add_subparser(subparsers: "argparse._SubParsersAction") -> None:
             "  For more information use:",
             "    odxtools find -h",
         ]),
-        help="Find & print services by hex-data, or name. Can also decode the request.",
+        help="Find & display services by their name",
         formatter_class=argparse.RawTextHelpFormatter,
     )
     _parser_utils.add_pdx_argument(parser)
@@ -120,6 +121,14 @@ def add_subparser(subparsers: "argparse._SubParsersAction") -> None:
         help="Relax output formatting rules (allow unknown bitlengths for ascii representation)",
     )
 
+    parser.add_argument(
+        "-po",
+        "--plumbing-output",
+        action="store_true",
+        required=False,
+        help="Print full objects instead of selected and formatted attributes",
+    )
+
 
 def run(args: argparse.Namespace) -> None:
     odxdb = _parser_utils.load_file(args)
@@ -131,4 +140,4 @@ def run(args: argparse.Namespace) -> None:
         service_names=args.service_names,
         print_params=not args.no_details,
         allow_unknown_bit_lengths=args.relaxed_output,
-    )
+        plumbing_output=args.plumbing_output)

odxtools/cli/list.py

@@ -2,40 +2,57 @@
 import argparse
 from typing import Callable, List, Optional
 
+from rich import print
+
 from ..database import Database
 from ..diagcomm import DiagComm
 from ..diaglayer import DiagLayer
 from ..diagservice import DiagService
 from ..singleecujob import SingleEcuJob
 from . import _parser_utils
-from ._print_utils import format_desc, print_diagnostic_service
+from ._print_utils import format_desc, print_diagnostic_service, print_dl_metrics
 
 # name of the tool
 _odxtools_tool_name_ = "list"
 
 
-def print_summary(
-    odxdb: Database,
-    print_global_negative_responses: bool = False,
-    print_services: bool = False,
-    print_dops: bool = False,
-    print_params: bool = False,
-    print_comparams: bool = False,
-    print_pre_condition_states: bool = False,
-    print_state_transitions: bool = False,
-    print_audiences: bool = False,
-    allow_unknown_bit_lengths: bool = False,
-    variants: Optional[str] = None,
-    service_filter: Callable[[DiagComm], bool] = lambda x: True,
-) -> None:
-
-    diag_layer_names = variants if variants else [dl.short_name for dl in odxdb.diag_layers]
-
-    for dl_sn in diag_layer_names:
-        dl = odxdb.diag_layers[dl_sn]
-        if not dl:
-            print(f"The variant '{dl_sn}' could not be found!")
-            continue
+def print_summary(odxdb: Database,
+                  print_global_negative_responses: bool = False,
+                  print_services: bool = False,
+                  print_dops: bool = False,
+                  print_params: bool = False,
+                  print_comparams: bool = False,
+                  print_pre_condition_states: bool = False,
+                  print_state_transitions: bool = False,
+                  print_audiences: bool = False,
+                  allow_unknown_bit_lengths: bool = False,
+                  variants: Optional[List[str]] = None,
+                  service_filter: Callable[[DiagComm], bool] = lambda x: True,
+                  plumbing_output: bool = False) -> None:
+
+    diag_layer_names = [dl.short_name for dl in odxdb.diag_layers]
+    diag_layers: List[DiagLayer] = []
+
+    if variants is None:
+        variants = diag_layer_names
+
+    for name in variants:
+        if name in diag_layer_names:
+            diag_layers.append([x for x in odxdb.diag_layers if x.short_name == name][0])
+
+        else:
+            print(f"The variant '{name}' could not be found!")
+            return
+
+    if diag_layers:
+        print("\n")
+        print(f"Overview of diagnostic layers: ")
+        print_dl_metrics(diag_layers)
+
+    for dl in diag_layers:
+        print("\n")
+        print(f"[green]Diagnostic layer:[/green] '[bold white]{dl.short_name}[/bold white]'")
+        print(f" [blue]Variant Type[/blue]: {dl.variant_type.value}")
 
         assert isinstance(dl, DiagLayer)
         all_services: List[DiagComm] = sorted(dl.services, key=lambda x: x.short_name)
@@ -43,31 +60,35 @@ def print_summary(
         data_object_properties = dl.diag_data_dictionary_spec.data_object_props
         comparams = dl.comparams
 
-        print(f"{dl.variant_type} '{dl.short_name}'")
-        print(
-            f" num services: {len(all_services)}, num DOPs: {len(data_object_properties)}, num communication parameters: {len(comparams)}."
-        )
-
         for proto in dl.protocols:
             if (can_rx_id := dl.get_can_receive_id(proto.short_name)) is not None:
-                print(f"  CAN receive ID for protocol '{proto.short_name}': 0x{can_rx_id:x}")
+                print(
+                    f"  [blue]CAN receive ID[/blue] for protocol '{proto.short_name}': 0x{can_rx_id:x}"
+                )
 
             if (can_tx_id := dl.get_can_send_id(proto.short_name)) is not None:
-                print(f"  CAN send ID for protocol '{proto.short_name}': 0x{can_tx_id:x}")
+                print(
+                    f"  [blue]CAN send ID[/blue] for protocol '{proto.short_name}': 0x{can_tx_id:x}"
+                )
 
         if dl.description:
             desc = format_desc(dl.description, ident=2)
-            print(f" Description: " + desc)
+            print(f" [blue]Description[/blue]: " + desc)
 
         if print_global_negative_responses and dl.global_negative_responses:
-            print(f"The global negative responses of '{dl.short_name}' are: ")
+            print("\n")
+            print(f"The [blue]global negative responses[/blue] of '{dl.short_name}' are: ")
             for gnr in dl.global_negative_responses:
-                print(f" {gnr}")
+                if plumbing_output:
+                    print(f" {gnr}")
+                else:
+                    print(f" {gnr.short_name}")
 
         if print_services and len(all_services) > 0:
             services = [s for s in all_services if service_filter(s)]
             if len(services) > 0:
-                print(f"The services of '{dl.short_name}' are: ")
+                print("\n")
+                print(f"The [blue]services[/blue] of '{dl.short_name}' are: ")
                 for service in services:
                     if isinstance(service, DiagService):
                         print_diagnostic_service(
@@ -77,21 +98,26 @@ def print_summary(
                             print_state_transitions=print_state_transitions,
                             print_audiences=print_audiences,
                             allow_unknown_bit_lengths=allow_unknown_bit_lengths,
-                        )
+                            plumbing_output=plumbing_output)
                     elif isinstance(service, SingleEcuJob):
-                        print(f" Single ECU job: {service.odx_id}")
+                        print(f" [blue]Single ECU job[/blue]: {service.odx_id}")
                     else:
                         print(f" Unidentifiable service: {service}")
 
         if print_dops and len(data_object_properties) > 0:
-            print(f"The DOPs of the {dl.variant_type} '{dl.short_name}' are: ")
+            print("\n")
+            print(f"The [blue]DOPs[/blue] of the {dl.variant_type.value} '{dl.short_name}' are: ")
             for dop in sorted(
                     data_object_properties, key=lambda x: (type(x).__name__, x.short_name)):
-                print("  " + str(dop).replace("\n", "\n  "))
+                if plumbing_output:
+                    print("  " + str(dop).replace("\n", "\n  "))
+                else:
+                    print("  " + str(dop.short_name).replace("\n", "\n  "))
 
         if print_comparams and len(comparams) > 0:
+            print("\n")
             print(
-                f"The communication parameters of the {dl.variant_type.value} '{dl.short_name}' are: "
+                f"The [blue]communication parameters[/blue] of the {dl.variant_type.value} '{dl.short_name}' are: "
             )
             for com_param in comparams:
                 print(f"  {com_param.short_name}: {com_param.value}")
@@ -178,6 +204,14 @@ def add_subparser(subparsers: "argparse._SubParsersAction") -> None:
         help="Print a list of all diagnostic services and DOPs specified in the pdx",
     )
 
+    parser.add_argument(
+        "-po",
+        "--plumbing-output",
+        action="store_true",
+        required=False,
+        help="Print full objects instead of selected and formatted attributes",
+    )
+
 
 def run(args: argparse.Namespace) -> None:
     odxdb = _parser_utils.load_file(args)
@@ -201,4 +235,4 @@ def run(args: argparse.Namespace) -> None:
         print_state_transitions=args.all,
         print_audiences=args.all,
         allow_unknown_bit_lengths=args.all,
-    )
+        plumbing_output=args.plumbing_output)

odxtools/cli/main.py

@@ -9,7 +9,7 @@ from .dummy_sub_parser import DummyTool
 # import the tool modules which can be loaded. if a tool
 # can't be loaded, add a dummy one
 tool_modules: List[Any] = []
-for tool_name in ["list", "browse", "snoop", "find", "decode"]:
+for tool_name in ["list", "browse", "snoop", "find", "decode", "compare"]:
     try:
         tool_modules.append(importlib.import_module(f".{tool_name}", package="odxtools.cli"))
     except Exception as e:

odxtools/database.py

@@ -4,6 +4,7 @@ from pathlib import Path
 from typing import List, Optional
 from xml.etree import ElementTree
 from zipfile import ZipFile
+
 from packaging.version import Version
 
 from .comparamspec import ComparamSpec

odxtools/dataobjectproperty.py

@@ -11,6 +11,7 @@ from .diagcodedtype import DiagCodedType
 from .dopbase import DopBase
 from .encodestate import EncodeState
 from .exceptions import DecodeError, EncodeError, odxassert, odxrequire
+from .internalconstr import InternalConstr
 from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef
 from .odxtypes import AtomicOdxType, ParameterValue
 from .physicaltype import PhysicalType
@@ -41,8 +42,8 @@ class DataObjectProperty(DopBase):
     #: The unit associated with physical values (e.g. 'm/s^2')
     unit_ref: Optional[OdxLinkRef]
 
-    # TODO: physical_const: Optional[InternalConstr]
-    # TODO: internal_const: Optional[InternalConstr]
+    internal_constr: Optional[InternalConstr]
+    physical_constr: Optional[InternalConstr]
 
     @staticmethod
     def from_et(et_element: ElementTree.Element,
@@ -63,11 +64,23 @@ class DataObjectProperty(DopBase):
         )
         unit_ref = OdxLinkRef.from_et(et_element.find("UNIT-REF"), doc_frags)
 
+        internal_constr = None
+        if (internal_constr_elem := et_element.find("INTERNAL-CONSTR")) is not None:
+            internal_constr = InternalConstr.from_et(
+                internal_constr_elem, internal_type=diag_coded_type.base_data_type)
+
+        physical_constr = None
+        if (physical_constr_elem := et_element.find("PHYS-CONSTR")) is not None:
+            physical_constr = InternalConstr.from_et(
+                physical_constr_elem, internal_type=diag_coded_type.base_data_type)
+
         return DataObjectProperty(
             diag_coded_type=diag_coded_type,
             physical_type=physical_type,
             compu_method=compu_method,
             unit_ref=unit_ref,
+            internal_constr=internal_constr,
+            physical_constr=physical_constr,
             **kwargs)
 
     def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:

odxtools/diagcodedtype.py

@@ -3,7 +3,10 @@ import abc
 from dataclasses import dataclass
 from typing import TYPE_CHECKING, Any, Dict, Literal, Optional, Tuple, Union
 
-import bitstruct
+try:
+    import bitstruct.c as bitstruct
+except ImportError:
+    import bitstruct
 
 from . import exceptions
 from .decodestate import DecodeState
@@ -23,8 +26,8 @@ ODX_TYPE_TO_FORMAT_LETTER = {
     DataType.A_FLOAT64: "f",
     DataType.A_BYTEFIELD: "r",
     DataType.A_UNICODE2STRING: "r",  # UTF-16 strings must be converted explicitly
-    DataType.A_ASCIISTRING: "t",
-    DataType.A_UTF8STRING: "t",
+    DataType.A_ASCIISTRING: "r",
+    DataType.A_UTF8STRING: "r",
 }
 
 # Allowed diag-coded types
@@ -66,8 +69,8 @@ class DiagCodedType(abc.ABC):
     def is_highlow_byte_order(self) -> bool:
         return self.is_highlow_byte_order_raw in [None, True]
 
-    def _extract_internal(
-        self,
+    @staticmethod
+    def _extract_internal_value(
         coded_message: bytes,
         byte_position: int,
         bit_position: int,
@@ -75,9 +78,11 @@ class DiagCodedType(abc.ABC):
         base_data_type: DataType,
         is_highlow_byte_order: bool,
     ) -> Tuple[AtomicOdxType, int]:
-        """Extract the internal value.
+        """Extract an internal value from a blob of raw bytes.
 
-        Helper method for `DiagCodedType.convert_bytes_to_internal`.
+        :return: Tuple with the internal value of the object and the
+                 byte position of the first undecoded byte after the
+                 extracted object.
         """
         # If the bit length is zero, return "empty" values of each type
         if bit_length == 0:
@@ -89,46 +94,45 @@ class DiagCodedType(abc.ABC):
         cursor_position = byte_position + byte_length
         extracted_bytes = coded_message[byte_position:cursor_position]
 
-        # Apply byteorder
-        if not is_highlow_byte_order and base_data_type not in [
-                DataType.A_UNICODE2STRING,
-                DataType.A_BYTEFIELD,
-                DataType.A_ASCIISTRING,
-                DataType.A_UTF8STRING,
+        # Apply byteorder for numerical objects. Note that doing this
+        # here might lead to garbage data being included in the result
+        # if the data to be extracted is not byte aligned and crosses
+        # byte boundaries, but it is what the specification says.
+        if not is_highlow_byte_order and base_data_type in [
+                DataType.A_INT32,
+                DataType.A_UINT32,
+                DataType.A_FLOAT32,
+                DataType.A_FLOAT64,
         ]:
             extracted_bytes = extracted_bytes[::-1]
 
-        format_letter = ODX_TYPE_TO_FORMAT_LETTER[base_data_type]
-        padding = 8 * byte_length - (bit_length + bit_position)
-        text_encoding = 'utf-8'
-        text_errors = 'strict'
-        if not exceptions.strict_mode:
-            text_errors = 'replace'
+        padding = (8 - (bit_length + bit_position) % 8) % 8
+        internal_value, = bitstruct.unpack_from(
+            f"{ODX_TYPE_TO_FORMAT_LETTER[base_data_type]}{bit_length}",
+            extracted_bytes,
+            offset=padding)
+
+        text_errors = 'strict' if exceptions.strict_mode else 'replace'
         if base_data_type == DataType.A_ASCIISTRING:
-            # The spec says ASCII, meaning only byte values 0-127
+            # 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.
+            # reason being iso-8859-1 never fails since it has a valid
+            # character mapping for every possible byte sequence.
             text_encoding = 'iso-8859-1'
-        internal_value = bitstruct.unpack_from(
-            f"{format_letter}{bit_length}",
-            extracted_bytes,
-            offset=padding,
-            text_encoding=text_encoding,
-            text_errors=text_errors,
-        )[0]
-
-        if base_data_type == DataType.A_UNICODE2STRING:
-            # Convert bytes to string with utf-16 decoding
-            if is_highlow_byte_order:
-                internal_value = internal_value.decode("utf-16-be")
-            else:
-                internal_value = internal_value.decode("utf-16-le")
+            internal_value = internal_value.decode(encoding=text_encoding, errors=text_errors)
+        elif base_data_type == DataType.A_UTF8STRING:
+            text_encoding = "utf-8"
+            internal_value = internal_value.decode(encoding=text_encoding, errors=text_errors)
+        elif base_data_type == DataType.A_UNICODE2STRING:
+            # For UTF-16, we need to manually decode the extracted
+            # bytes to a string
+            text_encoding = "utf-16-be" if is_highlow_byte_order else "utf-16-le"
+            internal_value = internal_value.decode(encoding=text_encoding, errors=text_errors)
 
         return internal_value, cursor_position
 
-    def _to_bytes(
-        self,
+    @staticmethod
+    def _encode_internal_value(
         internal_value: AtomicOdxType,
         bit_position: int,
         bit_length: int,
@@ -137,23 +141,46 @@ class DiagCodedType(abc.ABC):
     ) -> bytes:
         """Convert the internal_value to bytes."""
         # Check that bytes and strings actually fit into the bit length
-        if base_data_type in [DataType.A_BYTEFIELD]:
+        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 in [DataType.A_ASCIISTRING, DataType.A_UTF8STRING]:
+        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}.")
-        if base_data_type in [DataType.A_UNICODE2STRING]:
+        elif base_data_type == DataType.A_UTF8STRING:
             if not isinstance(internal_value, str):
                 odxraise()
-            if 16 * len(internal_value) > bit_length:
+
+            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}.")
 
@@ -167,33 +194,24 @@ class DiagCodedType(abc.ABC):
             return b''
 
         char = ODX_TYPE_TO_FORMAT_LETTER[base_data_type]
-
-        # The coded byte is divided into (0..0)(value)(0..0) with bit lengths (left_pad)(bit_length)(bit_position)
-        offset = (8 - ((bit_length + bit_position) % 8)) % 8
-        odxassert((0 <= offset and offset < 8 and (offset + bit_length + bit_position) % 8 == 0),
-                  f"Computational mistake, offset={offset}")
-        left_pad = f"p{offset}" if offset > 0 else ""
-
-        # Convert string to bytes with utf-16 encoding
-        if base_data_type == DataType.A_UNICODE2STRING:
-            if not isinstance(internal_value, str):
-                odxraise()
-            if is_highlow_byte_order:
-                internal_value = internal_value.encode("utf-16-be")
-            else:
-                internal_value = internal_value.encode("utf-16-le")
-
-        code = bitstruct.pack(f"{left_pad}{char}{bit_length}", internal_value)
-
-        if not is_highlow_byte_order and base_data_type not in [
-                DataType.A_UNICODE2STRING,
-                DataType.A_BYTEFIELD,
-                DataType.A_ASCIISTRING,
-                DataType.A_UTF8STRING,
+        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,
         ]:
-            code = code[::-1]
+            coded = coded[::-1]
 
-        return code
+        return coded
 
     def _minimal_byte_length_of(self, internal_value: Union[bytes, str]) -> int:
         """Helper method to get the minimal byte length.

odxtools/internalconstr.py

@@ -0,0 +1,34 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass
+from typing import List, Optional
+from xml.etree import ElementTree
+
+from .compumethods.limit import Limit
+from .odxtypes import DataType
+from .scaleconstr import ScaleConstr
+
+
+@dataclass
+class InternalConstr:
+    """This class represents INTERNAL-CONSTR objects.
+    """
+
+    # TODO: Enforce the internal and physical constraints.
+
+    lower_limit: Optional[Limit]
+    upper_limit: Optional[Limit]
+    scale_constrs: List[ScaleConstr]
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element, internal_type: DataType) -> "InternalConstr":
+
+        lower_limit = Limit.from_et(et_element.find("LOWER-LIMIT"), internal_type=internal_type)
+        upper_limit = Limit.from_et(et_element.find("UPPER-LIMIT"), internal_type=internal_type)
+
+        scale_constrs = [
+            ScaleConstr.from_et(sc_el, internal_type)
+            for sc_el in et_element.iterfind("SCALE-CONSTRS/SCALE-CONSTR")
+        ]
+
+        return InternalConstr(
+            lower_limit=lower_limit, upper_limit=upper_limit, scale_constrs=scale_constrs)

odxtools/leadinglengthinfotype.py

@@ -38,7 +38,7 @@ class LeadingLengthInfoType(DiagCodedType):
 
         byte_length = self._minimal_byte_length_of(internal_value)
 
-        length_byte = self._to_bytes(
+        length_bytes = self._encode_internal_value(
             byte_length,
             bit_position=bit_position,
             bit_length=self.bit_length,
@@ -46,7 +46,7 @@ class LeadingLengthInfoType(DiagCodedType):
             is_highlow_byte_order=self.is_highlow_byte_order,
         )
 
-        value_byte = self._to_bytes(
+        value_bytes = self._encode_internal_value(
             internal_value,
             bit_position=0,
             bit_length=8 * byte_length,
@@ -54,7 +54,7 @@ class LeadingLengthInfoType(DiagCodedType):
             is_highlow_byte_order=self.is_highlow_byte_order,
         )
 
-        return length_byte + value_byte
+        return length_bytes + value_bytes
 
     def convert_bytes_to_internal(self,
                                   decode_state: DecodeState,
@@ -62,7 +62,7 @@ class LeadingLengthInfoType(DiagCodedType):
         coded_message = decode_state.coded_message
 
         # Extract length of the parameter value
-        byte_length, byte_position = self._extract_internal(
+        byte_length, byte_position = self._extract_internal_value(
             coded_message=coded_message,
             byte_position=decode_state.cursor_position,
             bit_position=bit_position,
@@ -77,7 +77,7 @@ class LeadingLengthInfoType(DiagCodedType):
         # Extract actual value
         # TODO: The returned value is None if the byte_length is 0. Maybe change it
         #       to some default value like an empty bytearray() or 0?
-        value, cursor_position = self._extract_internal(
+        value, cursor_position = self._extract_internal_value(
             coded_message=coded_message,
             byte_position=byte_position,
             bit_position=0,

odxtools/minmaxlengthtype.py

@@ -63,7 +63,7 @@ class MinMaxLengthType(DiagCodedType):
             data_length = len(internal_value)
 
         value_bytes = bytearray(
-            self._to_bytes(
+            self._encode_internal_value(
                 internal_value,
                 bit_position=0,
                 bit_length=8 * data_length,
@@ -145,7 +145,7 @@ class MinMaxLengthType(DiagCodedType):
                     terminator_pos += 1
 
             # Extract the value
-            value, byte_pos = self._extract_internal(
+            value, byte_pos = self._extract_internal_value(
                 decode_state.coded_message,
                 byte_position=cursor_pos,
                 bit_position=bit_position,
@@ -164,7 +164,7 @@ class MinMaxLengthType(DiagCodedType):
             # or at the end of the PDU.
             byte_length = max_terminator_pos - cursor_pos
 
-            value, byte_pos = self._extract_internal(
+            value, byte_pos = self._extract_internal_value(
                 decode_state.coded_message,
                 byte_position=cursor_pos,
                 bit_position=bit_position,

odxtools/paramlengthinfotype.py

@@ -66,7 +66,7 @@ class ParamLengthInfoType(DiagCodedType):
         if bit_length is None:
             odxraise()
 
-        return self._to_bytes(
+        return self._encode_internal_value(
             internal_value,
             bit_position=bit_position,
             bit_length=bit_length,
@@ -91,7 +91,7 @@ class ParamLengthInfoType(DiagCodedType):
             odxraise(f"Did not find any length key with short name {self.length_key.short_name}")
 
         # Extract the internal value and return.
-        return self._extract_internal(
+        return self._extract_internal_value(
             decode_state.coded_message,
             decode_state.cursor_position,
             bit_position,