odxtools 8.3.4__py3-none-any.whl → 9.0.0__py3-none-any.whl

odxtools/cli/_print_utils.py

@@ -1,10 +1,12 @@
 # SPDX-License-Identifier: MIT
 import re
 import textwrap
-from typing import Any, Callable, Dict, List, Optional, Union
+from typing import List, Optional, Tuple, Union
 
 import markdownify
-from tabulate import tabulate  # TODO: switch to rich tables
+from rich import print as rich_print
+from rich.padding import Padding as RichPadding
+from rich.table import Table as RichTable
 
 from ..description import Description
 from ..diaglayers.diaglayer import DiagLayer
@@ -36,148 +38,179 @@ def print_diagnostic_service(service: DiagService,
                              print_pre_condition_states: bool = False,
                              print_state_transitions: bool = False,
                              print_audiences: bool = False,
-                             allow_unknown_bit_lengths: bool = False,
-                             print_fn: Callable[..., Any] = print) -> None:
+                             allow_unknown_bit_lengths: bool = False) -> None:
 
-    print_fn(f" Service '{service.short_name}':")
+    rich_print(f" Service '{service.short_name}':")
 
     if service.description:
         desc = format_desc(service.description, indent=3)
-        print_fn(f"  Description: " + desc)
+        rich_print(f"  Description: " + desc)
 
     if print_pre_condition_states and len(service.pre_condition_states) > 0:
         pre_condition_states_short_names = [
             pre_condition_state.short_name for pre_condition_state in service.pre_condition_states
         ]
-        print_fn(f"  Pre-Condition States: {', '.join(pre_condition_states_short_names)}")
+        rich_print(f"  Pre-Condition States: {', '.join(pre_condition_states_short_names)}")
 
     if print_state_transitions and len(service.state_transitions) > 0:
         state_transitions = [
             f"{state_transition.source_snref} -> {state_transition.target_snref}"
             for state_transition in service.state_transitions
         ]
-        print_fn(f"  State Transitions: {', '.join(state_transitions)}")
+        rich_print(f"  State Transitions: {', '.join(state_transitions)}")
 
     if print_audiences and service.audience:
         enabled_audiences_short_names = [
             enabled_audience.short_name for enabled_audience in service.audience.enabled_audiences
         ]
-        print_fn(f"  Enabled Audiences: {', '.join(enabled_audiences_short_names)}")
+        rich_print(f"  Enabled Audiences: {', '.join(enabled_audiences_short_names)}")
 
     if print_params:
-        print_service_parameters(
-            service, allow_unknown_bit_lengths=allow_unknown_bit_lengths, print_fn=print_fn)
+        print_service_parameters(service, allow_unknown_bit_lengths=allow_unknown_bit_lengths)
 
 
 def print_service_parameters(service: DiagService,
-                             allow_unknown_bit_lengths: bool = False,
-                             print_fn: Callable[..., Any] = print) -> None:
-    # prints parameter details of request, positive response and negative response of diagnostic service
+                             *,
+                             allow_unknown_bit_lengths: bool = False) -> None:
+    # prints parameter details of request, positive response and
+    # negative response of diagnostic service
 
     # Request
     if service.request:
-        print_fn(f"  Request '{service.request.short_name}':")
+        rich_print(f"  Request '{service.request.short_name}':")
         const_prefix = service.request.coded_const_prefix()
-        print_fn(
+        rich_print(
             f"    Identifying Prefix: 0x{const_prefix.hex().upper()} ({bytes(const_prefix)!r})")
-        print_fn(f"    Parameters:")
-        table = extract_parameter_tabulation_data(list(service.request.parameters))
-        table_str = textwrap.indent(tabulate(table, headers='keys', tablefmt='presto'), "    ")
-        print_fn()
-        print_fn(table_str)
-        print_fn()
+        rich_print(f"    Parameters:")
+        param_table = extract_parameter_tabulation_data(service.request.parameters)
+        rich_print(RichPadding(param_table, pad=(0, 0, 0, 4)))
+        rich_print()
     else:
-        print_fn(f"  No Request!")
+        rich_print(f"  No Request!")
 
     # Positive Responses
     if not service.positive_responses:
-        print_fn(f"  No positive responses")
+        rich_print(f"  No positive responses")
 
     for resp in service.positive_responses:
-        print_fn(f"  Positive Response '{resp.short_name}':")
-        print_fn(f"   Parameters:\n")
+        rich_print(f"  Positive Response '{resp.short_name}':")
+        rich_print(f"   Parameters:\n")
         table = extract_parameter_tabulation_data(list(resp.parameters))
-        table_str = textwrap.indent(tabulate(table, headers='keys', tablefmt='presto'), "    ")
-        print_fn(table_str)
-        print_fn()
+        rich_print(RichPadding(table, pad=(0, 0, 0, 4)))
+        rich_print()
 
     # Negative Response
     if not service.negative_responses:
-        print_fn(f"  No negative responses")
+        rich_print(f"  No negative responses")
 
     for resp in service.negative_responses:
-        print_fn(f" Negative Response '{resp.short_name}':")
-        print_fn(f"   Parameters:\n")
+        rich_print(f" Negative Response '{resp.short_name}':")
+        rich_print(f"   Parameters:\n")
         table = extract_parameter_tabulation_data(list(resp.parameters))
-        table_str = textwrap.indent(tabulate(table, headers='keys', tablefmt='presto'), "    ")
-        print_fn(table_str)
-        print_fn()
+        rich_print(RichPadding(table, pad=(0, 0, 0, 4)))
+        rich_print()
 
-    print_fn("\n")
+    rich_print("\n")
 
 
-def extract_service_tabulation_data(services: List[DiagService]) -> Dict[str, Any]:
-    # extracts data of diagnostic services into Dictionary which can be printed by tabulate module
-    # TODO: consider indentation
+def extract_service_tabulation_data(services: List[DiagService],
+                                    *,
+                                    additional_columns: Optional[List[Tuple[str, List[str]]]] = None
+                                   ) -> RichTable:
+    """Extracts data of diagnostic services into Dictionary which can
+    be printed by tabulate module
+    """
 
-    name = []
-    semantic = []
-    request: List[Optional[str]] = []
+    # Create Rich table
+    table = RichTable(
+        title="", show_header=True, header_style="bold cyan", border_style="blue", show_lines=True)
+
+    name_column: List[str] = []
+    semantic_column: List[str] = []
+    request_column: List[str] = []
 
     for service in services:
-        name.append(service.short_name)
-        semantic.append(service.semantic)
+        name_column.append(service.short_name)
+        semantic_column.append(service.semantic or "")
 
         if service.request:
             prefix = service.request.coded_const_prefix()
-            request.append(f"0x{str(prefix.hex().upper())[:32]}...") if len(
-                prefix) > 32 else request.append(f"0x{str(prefix.hex().upper())}")
+            request_column.append(f"0x{str(prefix.hex().upper())[:32]}...") if len(
+                prefix) > 32 else request_column.append(f"0x{str(prefix.hex().upper())}")
         else:
-            request.append(None)
-
-    return {'Name': name, 'Semantic': semantic, 'Hex-Request': request}
-
-
-def extract_parameter_tabulation_data(parameters: List[Parameter]) -> Dict[str, Any]:
-    # extracts data of parameters of diagnostic services into Dictionary which can be printed by tabulate module
-    # TODO: consider indentation
-
-    name = []
-    byte = []
-    bit_length: List[Optional[int]] = []
-    semantic = []
-    param_type = []
-    value: List[Optional[str]] = []
-    value_type: List[Optional[str]] = []
-    data_type: List[Optional[str]] = []
-    dop: List[Optional[str]] = []
+            request_column.append("")
+
+    table.add_column("Name", style="green")
+    table.add_column("Semantic", justify="left", style="white")
+    table.add_column("Request", justify="left", style="white")
+    if additional_columns is not None:
+        for ac_title, _ in additional_columns:
+            table.add_column(ac_title, justify="left", style="white")
+
+        rows = zip(name_column, semantic_column, request_column,
+                   *[ac[1] for ac in additional_columns])
+        for row in rows:
+            table.add_row(*map(str, row))
+
+    return table
+
+
+def extract_parameter_tabulation_data(parameters: List[Parameter]) -> RichTable:
+    # extracts data of parameters of diagnostic services into
+    # a RichTable object that can be printed
+
+    # Create Rich table
+    table = RichTable(
+        title="", show_header=True, header_style="bold cyan", border_style="blue", show_lines=True)
+
+    # Add columns with appropriate styling
+    table.add_column("Name", style="green")
+    table.add_column("Byte Position", justify="right", style="yellow")
+    table.add_column("Bit Length", justify="right", style="yellow")
+    table.add_column("Semantic", justify="left", style="white")
+    table.add_column("Parameter Type", justify="left", style="white")
+    table.add_column("Data Type", justify="left", style="white")
+    table.add_column("Value", justify="left", style="yellow")
+    table.add_column("Value Type", justify="left", style="white")
+    table.add_column("Linked DOP", justify="left", style="white")
+
+    name_column: List[str] = []
+    byte_column: List[str] = []
+    bit_length_column: List[str] = []
+    semantic_column: List[str] = []
+    param_type_column: List[str] = []
+    value_column: List[str] = []
+    value_type_column: List[str] = []
+    data_type_column: List[str] = []
+    dop_column: List[str] = []
 
     for param in parameters:
-        name.append(param.short_name)
-        byte.append(param.byte_position)
-        semantic.append(param.semantic)
-        param_type.append(param.parameter_type)
+        name_column.append(param.short_name)
+        byte_column.append("" if param.byte_position is None else str(param.byte_position))
+        semantic_column.append(param.semantic or "")
+        param_type_column.append(param.parameter_type)
         length = 0
         if param.get_static_bit_length() is not None:
-            bit_length.append(param.get_static_bit_length())
-            length = (param.get_static_bit_length() or 0) // 4
+            n = param.get_static_bit_length()
+            bit_length_column.append("" if n is None else str(n))
+            length = (n or 0) // 4
         else:
-            bit_length.append(None)
+            bit_length_column.append("")
         if isinstance(param, CodedConstParameter):
             if isinstance(param.coded_value, int):
-                value.append(f"0x{param.coded_value:0{length}X}")
+                value_column.append(f"0x{param.coded_value:0{length}X}")
             elif isinstance(param.coded_value, bytes) or isinstance(param.coded_value, bytearray):
-                value.append(f"0x{param.coded_value.hex().upper()}")
+                value_column.append(f"0x{param.coded_value.hex().upper()}")
             else:
-                value.append(f"{param.coded_value!r}")
-            data_type.append(param.diag_coded_type.base_data_type.name)
-            value_type.append('coded value')
-            dop.append(None)
+                value_column.append(f"{param.coded_value!r}")
+            data_type_column.append(param.diag_coded_type.base_data_type.name)
+            value_type_column.append('coded value')
+            dop_column.append("")
         elif isinstance(param, NrcConstParameter):
-            data_type.append(param.diag_coded_type.base_data_type.name)
-            value.append(str(param.coded_values))
-            value_type.append('coded values')
-            dop.append(None)
+            data_type_column.append(param.diag_coded_type.base_data_type.name)
+            value_column.append(str(param.coded_values))
+            value_type_column.append('coded values')
+            dop_column.append("")
         elif isinstance(param, (PhysicalConstantParameter, SystemParameter, ValueParameter)):
             # this is a hack to make this routine work for parameters
             # which reference DOPs of a type that a is not yet
@@ -186,72 +219,71 @@ def extract_parameter_tabulation_data(parameters: List[Parameter]) -> Dict[str,
             param_dop = getattr(param, "_dop", None)
 
             if param_dop is not None:
-                dop.append(param_dop.short_name)
+                dop_column.append(param_dop.short_name)
 
             if param_dop is not None and (phys_type := getattr(param, "physical_type",
                                                                None)) is not None:
-                data_type.append(phys_type.base_data_type.name)
+                data_type_column.append(phys_type.base_data_type.name)
             else:
-                data_type.append(None)
+                data_type_column.append("")
             if isinstance(param, PhysicalConstantParameter):
                 if isinstance(param.physical_constant_value, bytes) or isinstance(
                         param.physical_constant_value, bytearray):
-                    value.append(f"0x{param.physical_constant_value.hex().upper()}")
+                    value_column.append(f"0x{param.physical_constant_value.hex().upper()}")
                 else:
-                    value.append(f"{param.physical_constant_value!r}")
-                value_type.append('constant value')
+                    value_column.append(f"{param.physical_constant_value!r}")
+                value_type_column.append('constant value')
             elif isinstance(param, ValueParameter) and param.physical_default_value is not None:
                 if isinstance(param.physical_default_value, bytes) or isinstance(
                         param.physical_default_value, bytearray):
-                    value.append(f"0x{param.physical_default_value.hex().upper()}")
+                    value_column.append(f"0x{param.physical_default_value.hex().upper()}")
                 else:
-                    value.append(f"{param.physical_default_value!r}")
-                value_type.append('default value')
+                    value_column.append(f"{param.physical_default_value!r}")
+                value_type_column.append('default value')
             else:
-                value.append(None)
-                value_type.append(None)
+                value_column.append("")
+                value_type_column.append("")
         else:
-            value.append(None)
-            data_type.append(None)
-            value_type.append(None)
-            dop.append(None)
-
-    return {
-        'Name': name,
-        'Byte Position': byte,
-        'Bit Length': bit_length,
-        'Semantic': semantic,
-        'Parameter Type': param_type,
-        'Data Type': data_type,
-        'Value': value,
-        'Value Type': value_type,
-        'Linked DOP': dop
-    }
-
-
-def print_dl_metrics(variants: List[DiagLayer], print_fn: Callable[..., Any] = print) -> None:
-
-    name = []
-    type = []
-    num_services = []
-    num_dops = []
-    num_comparam_refs = []
+            value_column.append("")
+            data_type_column.append("")
+            value_type_column.append("")
+            dop_column.append("")
+
+    # Add all rows at once by zipping dictionary values
+    rows = zip(name_column, byte_column, bit_length_column, semantic_column, param_type_column,
+               data_type_column, value_column, value_type_column, dop_column)
+    for row in rows:
+        table.add_row(*map(str, row))
+
+    return table
+
+
+def print_dl_metrics(variants: List[DiagLayer]) -> None:
+    """
+    Print diagnostic layer metrics using Rich tables.
+    Args:
+        variants: List of diagnostic layer variants to analyze
+    """
+    # Create Rich table
+    table = RichTable(
+        title="", show_header=True, header_style="bold cyan", border_style="blue", show_lines=True)
+
+    # Add columns with appropriate styling
+    table.add_column("Name", style="green")
+    table.add_column("Variant Type", style="magenta")
+    table.add_column("Number of Services", justify="right", style="yellow")
+    table.add_column("Number of DOPs", justify="right", style="yellow")
+    table.add_column("Number of communication parameters", justify="right", style="yellow")
+
+    # Process each variant
     for variant in variants:
         assert isinstance(variant, DiagLayer)
         all_services: List[Union[DiagService, SingleEcuJob]] = sorted(
             variant.services, key=lambda x: x.short_name)
-        name.append(variant.short_name)
-        type.append(variant.variant_type.value)
-        num_services.append(len(all_services))
         ddds = variant.diag_data_dictionary_spec
-        num_dops.append(len(ddds.data_object_props))
-        num_comparam_refs.append(len(getattr(variant, "comparams_refs", [])))
-
-    table = {
-        'Name': name,
-        'Variant Type': type,
-        'Number of Services': num_services,
-        'Number of DOPs': num_dops,
-        'Number of communication parameters': num_comparam_refs
-    }
-    print_fn(tabulate(table, headers='keys', tablefmt='presto'))
+
+        # Add row to table
+        table.add_row(variant.short_name, variant.variant_type.value, str(len(all_services)),
+                      str(len(ddds.data_object_props)),
+                      str(len(getattr(variant, "comparams_refs", []))))
+    rich_print(table)

odxtools/cli/browse.py

@@ -5,14 +5,16 @@ import sys
 from typing import List, Optional, Union, cast
 
 import InquirerPy.prompt as IP_prompt
-from tabulate import tabulate  # TODO: switch to rich tables
 
+from ..complexdop import ComplexDop
 from ..database import Database
 from ..dataobjectproperty import DataObjectProperty
 from ..diaglayer import DiagLayer
 from ..diagservice import DiagService
+from ..dopbase import DopBase
 from ..exceptions import odxraise, odxrequire
 from ..hierarchyelement import HierarchyElement
+from ..odxlink import resolve_snref
 from ..odxtypes import AtomicOdxType, DataType, ParameterValueDict
 from ..parameters.matchingrequestparameter import MatchingRequestParameter
 from ..parameters.parameter import Parameter
@@ -111,24 +113,44 @@ def prompt_single_parameter_value(parameter: Parameter) -> Optional[AtomicOdxTyp
         return cast(str, answer.get(parameter.short_name))
 
 
-def encode_message_interactively(sub_service: Union[Request, Response],
+def encode_message_interactively(codec: Union[Request, Response],
                                  ask_user_confirmation: bool = False) -> None:
     if sys.__stdin__ is None or sys.__stdout__ is None or not sys.__stdin__.isatty(
     ) or not sys.__stdout__.isatty():
         raise SystemError("This command can only be used in an interactive shell!")
-    param_dict = sub_service.parameter_dict()
 
-    exists_definable_param = False
-    for param_or_dict in param_dict.values():
-        if isinstance(param_or_dict, dict):
-            for param in param_or_dict.values():
-                if isinstance(param, Parameter) and param.is_settable:
-                    exists_definable_param = True
-        elif param_or_dict.is_settable:
-            exists_definable_param = True
+    answered_request = b''
+    if isinstance(codec, Response):
+        answered_request_prompt = [{
+            "type":
+                "input",
+            "name":
+                "request",
+            "message":
+                f"What is the request you want to answer? (Enter the coded request as integer in hexadecimal format (e.g. 12 3B 5)",
+            "filter":
+                lambda input: _convert_string_to_bytes(input),
+        }]
+        answer = IP_prompt(answered_request_prompt)
+        answered_request = cast(bytes, answer.get("request"))
+        print(f"Input interpretation as list: {list(answered_request)}")
+
+    has_settable_param = False
+    for param in codec.parameters:
+        if not param.is_settable:
+            continue
+
+        # TODO: Specifying complex parameters with nesting depth > 1
+        # is not possible yet
+        if (inner_params := getattr(getattr(param, "dop", None), "parameters", None)) is not None:
+            for inner_param in inner_params:
+                if inner_param.is_settable:
+                    has_settable_param = True
+        elif param.is_settable:
+            has_settable_param = True
 
     param_values: ParameterValueDict = {}
-    if exists_definable_param > 0:
+    if has_settable_param:
         # Ask whether user wants to encode a message
         if ask_user_confirmation:
             encode_message_prompt = [{
@@ -141,48 +163,40 @@ def encode_message_interactively(sub_service: Union[Request, Response],
             if answer.get("yes_no_prompt") == "no":
                 return
 
-        answered_request = b''
-        if isinstance(sub_service, Response):
-            answered_request_prompt = [{
-                "type":
-                    "input",
-                "name":
-                    "request",
-                "message":
-                    f"What is the request you want to answer? (Enter the coded request as integer in hexadecimal format (e.g. 12 3B 5)",
-                "filter":
-                    lambda input: _convert_string_to_bytes(input),
-            }]
-            answer = IP_prompt(answered_request_prompt)
-            answered_request = cast(bytes, answer.get("request"))
-            print(f"Input interpretation as list: {list(answered_request)}")
-
-        # Request values for parameters
-        for key, param_or_structure in param_dict.items():
-            if isinstance(param_or_structure, dict):
-                # param_or_structure refers to a structure (represented as dict of params)
+        # Query user for the values of all settable parameters
+        for param in codec.parameters:
+            if (inner_params := getattr(dop := getattr(param, "dop", None), "parameters",
+                                        None)) is not None:
+                assert isinstance(dop, DopBase)
+                inner_params = cast(List[Parameter], inner_params)
+                # param refers to a complex DOP, i.e., the required
+                # value is a key-value dict
                 print(
-                    f"The next {len(param_or_structure)} parameters belong to the structure '{key}'"
+                    f"The next {len(inner_params)} parameters belong to the structure '{dop.short_name}'"
                 )
                 structure_param_values: ParameterValueDict = {}
-                for param_sn, param in param_or_structure.items():
-                    if not isinstance(param, dict) and param.is_settable:
-                        val = prompt_single_parameter_value(param)
+                for inner_param in inner_params:
+                    if inner_param.is_settable:
+                        val = prompt_single_parameter_value(inner_param)
                         if val is not None:
-                            structure_param_values[param_sn] = val
-                param_values[key] = structure_param_values
-            elif param_or_structure.is_settable:
-                # param_or_structure is a parameter
-                val = prompt_single_parameter_value(param_or_structure)
+                            structure_param_values[inner_param.short_name] = val
+                param_values[param.short_name] = structure_param_values
+            elif param.is_settable:
+                val = prompt_single_parameter_value(param)
                 if val is not None:
-                    param_values[key] = val
-        if isinstance(sub_service, Response):
-            payload = sub_service.encode(coded_request=answered_request, **param_values)
+                    param_values[param.short_name] = val
+
+        if isinstance(codec, Response):
+            payload = codec.encode(coded_request=answered_request, **param_values)
         else:
-            payload = sub_service.encode(coded_request=b'', **param_values)
+            payload = codec.encode(coded_request=b'', **param_values)
     else:
-        # There are no optional parameters that need to be defined by the user -> Just print message
-        payload = sub_service.encode()
+        # There are no settable parameters -> Just print message
+        if isinstance(codec, Response):
+            payload = codec.encode(coded_request=answered_request)
+        else:
+            payload = codec.encode()
+
     print(f"Message payload: 0x{bytes(payload).hex()}")
 
 
@@ -193,56 +207,58 @@ def encode_message_from_string_values(
     if parameter_values is None:
         parameter_values = {}
     parameter_values = parameter_values.copy()
-    param_dict = sub_service.parameter_dict()
 
-    # Check if all needed parameters are given
+    # Check if all needed parameters have been specified
     missing_parameter_names = []
-    for param_sn, param in param_dict.items():
-        if isinstance(param, dict):
-            # param_value refers to a structure (represented as dict of params)
-            for simple_param_sn, simple_param in param.items():
-                structured_value = parameter_values.get(param_sn)
-                if not isinstance(simple_param, Parameter):
-                    continue
-                if simple_param.is_required and (not isinstance(structured_value, dict) or
-                                                 structured_value.get(simple_param_sn) is None):
-                    missing_parameter_names.append(f"{param_sn} :: {simple_param_sn}")
+    for param in sub_service.parameters:
+        if (inner_params := getattr(dop := getattr(param, "dop", None), "parameters",
+                                    None)) is not None:
+            inner_param_values = parameter_values.get(param.short_name, {})
+            if not isinstance(inner_param_values, dict):
+                print(f"Value for composite parameter {param.short_name} must be "
+                      f"a dictionary, got {type(inner_param_values).__name__}")
+                continue
+            for inner_param in inner_params:
+                if inner_param.is_required and inner_param.short_name not in inner_param_values:
+                    missing_parameter_names.append(f"{param.short_name}.{inner_param.short_name}")
         else:
-            if param.is_required and parameter_values.get(param_sn) is None:
-                missing_parameter_names.append(param_sn)
+            if param.is_required and parameter_values.get(param.short_name) is None:
+                missing_parameter_names.append(param.short_name)
 
     if len(missing_parameter_names) > 0:
-        print("The following parameters are required but missing!")
-        print(" - " + "\n - ".join(missing_parameter_names))
+        print("The following parameters are required but missing:")
+        print(" - " + "\n - ".join(sorted(missing_parameter_names)))
         return
 
     # Request values for parameters
     for parameter_sn, parameter_value in parameter_values.items():
-        parameter = param_dict.get(parameter_sn)
+        parameter = resolve_snref(parameter_sn, sub_service.parameters, Parameter)
         if parameter is None:
             print(f"I don't know the parameter {parameter_sn}")
             continue
 
         if isinstance(parameter_value, dict):
             # parameter_value refers to a structure (represented as dict of params)
+            dop = getattr(parameter, "dop", None)
+            inner_params = getattr(dop, "parameters", None)
+            assert isinstance(dop, ComplexDop)
+            assert isinstance(inner_params, list)
+            inner_params = cast(List[Parameter], inner_params)
+
             typed_dict = parameter_value.copy()
-            for simple_param_sn, simple_param_val in parameter_value.items():
-                simple_parameter = param_dict.get(simple_param_sn)
-                if simple_parameter is None:
-                    print(f"Unknown sub-parameter {simple_param_sn}")
+            for inner_param_sn, inner_param_value in parameter_value.items():
+                inner_param = resolve_snref(inner_param_sn, inner_params, Parameter)
+                if inner_param is None:
+                    print(f"Unknown sub-parameter {inner_param_sn}")
                     continue
-                if not isinstance(simple_param_val, str):
-                    print(f"The value specified for parameter {simple_param_sn} is not a string")
+                if not isinstance(inner_param_value, str):
+                    print(f"The value specified for parameter {inner_param_sn} is not a string")
                     continue
 
-                typed_dict[simple_param_sn] = _convert_string_to_odx_type(
-                    simple_param_val,
-                    simple_parameter.physical_type.base_data_type  # type: ignore[union-attr]
-                )
-                parameter_values[parameter_sn] = typed_dict
+                typed_dict[inner_param_sn] = _convert_string_to_odx_type(
+                    inner_param_value, inner_param.physical_type.base_data_type)
+            parameter_values[parameter.short_name] = typed_dict
         else:
-            assert isinstance(parameter, Parameter)
-
             if not isinstance(parameter_value, str):
                 print(f"Value for parameter {parameter_sn} is not a string")
                 continue
@@ -356,8 +372,7 @@ def browse(odxdb: Database) -> None:
             if codec is not None:
                 assert isinstance(codec, (Request, Response))
                 table = extract_parameter_tabulation_data(codec.parameters)
-                table_str = tabulate(table, headers='keys', tablefmt='presto')
-                print(table_str)
+                print(table)
 
                 encode_message_interactively(codec, ask_user_confirmation=True)