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

odxtools/cli/browse.py

@@ -5,13 +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
@@ -110,23 +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 not sys.__stdin__.isatty() or not sys.__stdout__.isatty():
+    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 = [{
@@ -139,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()}")
 
 
@@ -191,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
@@ -260,7 +278,8 @@ def encode_message_from_string_values(
 
 
 def browse(odxdb: Database) -> None:
-    if not sys.__stdin__.isatty() or not sys.__stdout__.isatty():
+    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!")
     dl_names = [dl.short_name for dl in odxdb.diag_layers]
     while True:
@@ -281,19 +300,20 @@ def browse(odxdb: Database) -> None:
         print(f"{type(answer.get('variant'))=}")
         assert isinstance(variant, DiagLayer)
 
-        if (rx_id := variant.get_receive_id()) is not None:
-            recv_id = hex(rx_id)
-        else:
-            recv_id = "None"
+        if isinstance(variant, HierarchyElement):
+            if (rx_id := variant.get_receive_id()) is not None:
+                recv_id = hex(rx_id)
+            else:
+                recv_id = "None"
 
-        if (tx_id := variant.get_send_id()) is not None:
-            send_id = hex(tx_id)
-        else:
-            send_id = "None"
+            if (tx_id := variant.get_send_id()) is not None:
+                send_id = hex(tx_id)
+            else:
+                send_id = "None"
 
-        print(
-            f"{variant.variant_type.value} '{variant.short_name}' (Receive ID: {recv_id}, Send ID: {send_id})"
-        )
+            print(
+                f"{variant.variant_type.value} '{variant.short_name}' (Receive ID: {recv_id}, Send ID: {send_id})"
+            )
 
         while True:
             services: List[DiagService] = [
@@ -352,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)
 

odxtools/cli/compare.py

@@ -5,13 +5,14 @@ import argparse
 import os
 from typing import Any, Dict, List, Optional, Set, Union, cast
 
-from rich import print
-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 ..database import Database
-from ..diaglayer import DiagLayer
+from ..diaglayers.diaglayer import DiagLayer
 from ..diagservice import DiagService
-from ..load_file import load_file
+from ..loadfile import load_file
 from ..odxtypes import AtomicOdxType
 from ..parameters.codedconstparameter import CodedConstParameter
 from ..parameters.nrcconstparameter import NrcConstParameter
@@ -46,11 +47,14 @@ class Display:
     # class with variables and functions to display the result of the comparison
 
     # TODO
-    # Idea: results as json export
-    # - write results of comparison in json structure
-    # - use odxlinks to refer to dignostic services / objects if changes have already been detected (e.g. in another ecu variant / diagnostic layer)
-
-    # print all information about parameter properties (request, pos. response & neg. response parameters) for changed diagnostic services
+    # - Idea: results as json export
+    #  - write results of comparison in json structure
+    #  - use odxlinks to refer to dignostic services / objects if
+    #    changes have already been detected (e.g. in another ecu
+    #    variant / diagnostic layer)
+    # - print all information about parameter properties (request,
+    #   pos. response & neg. response parameters) for changed diagnostic
+    #   services
     param_detailed: bool
     obj_detailed: bool
 
@@ -62,46 +66,45 @@ class Display:
         if service_dict["new_services"] or service_dict["deleted_services"] or service_dict[
                 "changed_name_of_service"][0] or service_dict["changed_parameters_of_service"][0]:
             assert isinstance(service_dict["diag_layer"], str)
-            print()
-            print(
+            rich_print()
+            rich_print(
                 f"Changed diagnostic services for diagnostic layer '{service_dict['diag_layer']}' ({service_dict['diag_layer_type']}):"
             )
         if service_dict["new_services"]:
             assert isinstance(service_dict["new_services"], List)
-            print()
-            print(" [blue]New services[/blue]")
-            table = extract_service_tabulation_data(
-                service_dict["new_services"])  # type: ignore[arg-type]
-            print(tabulate(table, headers="keys", tablefmt="presto"))
+            rich_print()
+            rich_print(" [blue]New services[/blue]")
+            rich_print(extract_service_tabulation_data(
+                service_dict["new_services"]))  # type: ignore[arg-type]
         if service_dict["deleted_services"]:
             assert isinstance(service_dict["deleted_services"], List)
-            print()
-            print(" [blue]Deleted services[/blue]")
-            table = extract_service_tabulation_data(
-                service_dict["deleted_services"])  # type: ignore[arg-type]
-            print(tabulate(table, headers="keys", tablefmt="presto"))
+            rich_print()
+            rich_print(" [blue]Deleted services[/blue]")
+            rich_print(extract_service_tabulation_data(
+                service_dict["deleted_services"]))  # type: ignore[arg-type]
         if service_dict["changed_name_of_service"][0]:
-            print()
-            print(" [blue]Renamed services[/blue]")
-            table = extract_service_tabulation_data(
-                service_dict["changed_name_of_service"][0])  # type: ignore[arg-type]
-            table["Old service name"] = service_dict["changed_name_of_service"][1]
-            print(tabulate(table, headers="keys", tablefmt="presto"))
+            rich_print()
+            rich_print(" [blue]Renamed services[/blue]")
+            rich_print(extract_service_tabulation_data(
+                service_dict["changed_name_of_service"][0]))  # type: ignore[arg-type]
         if service_dict["changed_parameters_of_service"][0]:
-            print()
-            print(" [blue]Services with parameter changes[/blue]")
+            rich_print()
+            rich_print(" [blue]Services with parameter changes[/blue]")
             # create table with information about services with parameter changes
+            changed_param_column = [
+                str(x) for x in service_dict["changed_parameters_of_service"][
+                    1]  # type: ignore[union-attr]
+            ]
             table = extract_service_tabulation_data(
-                service_dict["changed_parameters_of_service"][0])  # type: ignore[arg-type]
-            # add information about changed parameters
-            table["Changed parameters"] = service_dict["changed_parameters_of_service"][1]
-            print(tabulate(table, headers="keys", tablefmt="presto"))
+                service_dict["changed_parameters_of_service"][0],  # type: ignore[arg-type]
+                additional_columns=[("Changed Parameters", changed_param_column)])
+            rich_print(table)
 
             for service_idx, service in enumerate(
                     service_dict["changed_parameters_of_service"][0]):  # type: ignore[arg-type]
                 assert isinstance(service, DiagService)
-                print()
-                print(
+                rich_print()
+                rich_print(
                     f"  Detailed changes of diagnostic service [u cyan]{service.short_name}[/u cyan]"
                 )
                 #   detailed_info in [infotext1, dict1, infotext2, dict2, ...]
@@ -110,10 +113,22 @@ class Display:
                     service_dict["changed_parameters_of_service"])[2][service_idx]
                 for detailed_info in info_list:
                     if isinstance(detailed_info, str):
-                        print()
-                        print(detailed_info)
+                        rich_print()
+                        rich_print(detailed_info)
                     elif isinstance(detailed_info, dict):
-                        print(tabulate(detailed_info, headers="keys", tablefmt="presto"))
+                        table = RichTable(
+                            show_header=True,
+                            header_style="bold cyan",
+                            border_style="blue",
+                            show_lines=True)
+                        for header in detailed_info:
+                            table.add_column(header)
+                        rows = zip(*detailed_info.values())
+                        for row in rows:
+                            table.add_row(*map(str, row))
+
+                        rich_print(RichPadding(table, pad=(0, 0, 0, 4)))
+                        rich_print()
                 if self.param_detailed:
                     # print all parameter details of diagnostic service
                     print_service_parameters(service, allow_unknown_bit_lengths=True)
@@ -124,16 +139,18 @@ class Display:
         # diagnostic layers
         if changes_variants["new_diagnostic_layers"] or changes_variants[
                 "deleted_diagnostic_layers"]:
-            print()
-            print("[bright_blue]Changed diagnostic layers[/bright_blue]: ")
-            print(" New diagnostic layers: ")
+            rich_print()
+            rich_print("[bright_blue]Changed diagnostic layers[/bright_blue]: ")
+            rich_print(" New diagnostic layers: ")
             for variant in changes_variants["new_diagnostic_layers"]:
                 assert isinstance(variant, DiagLayer)
-                print(f"  [magenta]{variant.short_name}[/magenta] ({variant.variant_type.value})")
-            print(" Deleted diagnostic layers: ")
+                rich_print(
+                    f"  [magenta]{variant.short_name}[/magenta] ({variant.variant_type.value})")
+            rich_print(" Deleted diagnostic layers: ")
             for variant in changes_variants["deleted_diagnostic_layers"]:
                 assert isinstance(variant, DiagLayer)
-                print(f"  [magenta]{variant.short_name}[/magenta] ({variant.variant_type.value})")
+                rich_print(
+                    f"  [magenta]{variant.short_name}[/magenta] ({variant.variant_type.value})")
 
         # diagnostic services
         for _, value in changes_variants.items():
@@ -275,8 +292,8 @@ class Comparison(Display):
                     if res1_idx == res2_idx:
                         # find changed request parameter properties
                         table = self.compare_parameters(param1, param2)
-                        infotext = (f"   Properties of request parameter '{param2.short_name}'"
-                                    f" have changed\n")
+                        infotext = (f"   Properties of request parameter '{param2.short_name}' "
+                                    f"that have changed:\n")
                         # array index starts with 0 -> param[0] is 1. service parameter
 
                         if table["Property"]:
@@ -311,8 +328,8 @@ class Comparison(Display):
                                         # find changed positive response parameter properties
                                         table = self.compare_parameters(param1, param2)
                                         infotext = (
-                                            f"   Properties of positive response parameter '{param2.short_name}'"
-                                            f"have changed\n")
+                                            f"   Properties of positive response parameter '{param2.short_name}' that "
+                                            f"have changed:\n")
                                         # array index starts with 0 -> param[0] is first service parameter
 
                                         if table["Property"]:
@@ -354,7 +371,7 @@ class Comparison(Display):
                                     if param1_idx == param2_idx:
                                         # find changed negative response parameter properties
                                         table = self.compare_parameters(param1, param2)
-                                        infotext = f"   Properties of response parameter '{param2.short_name}' have changed\n"
+                                        infotext = f"   Properties of response parameter '{param2.short_name}' that have changed:\n"
                                         # array index starts with 0 -> param[0] is 1. service parameter
 
                                         if table["Property"]:
@@ -622,7 +639,7 @@ def run(args: argparse.Namespace) -> None:
 
         for name in args.variants:
             if name not in task.diagnostic_layer_names:
-                print(f"The variant '{name}' could not be found!")
+                rich_print(f"The variant '{name}' could not be found!")
                 return
 
         task.db_indicator_1 = 0
@@ -632,19 +649,20 @@ def run(args: argparse.Namespace) -> None:
                 break
             task.db_indicator_2 = db_idx + 1
 
-            print()
-            print(f"Changes in file '{os.path.basename(db_names[0])}'")
-            print(f" (compared to '{os.path.basename(db_names[db_idx + 1])}')")
+            rich_print()
+            rich_print(f"Changes in file '{os.path.basename(db_names[0])}'")
+            rich_print(f" (compared to '{os.path.basename(db_names[db_idx + 1])}')")
 
-            print()
-            print(f"Overview of diagnostic layers (for {os.path.basename(db_names[0])})")
+            rich_print()
+            rich_print(f"Overview of diagnostic layers (for {os.path.basename(db_names[0])})")
             print_dl_metrics([
                 variant for variant in task.databases[0].diag_layers
                 if variant.short_name in task.diagnostic_layer_names
             ])
 
-            print()
-            print(f"Overview of diagnostic layers (for {os.path.basename(db_names[db_idx+1])})")
+            rich_print()
+            rich_print(
+                f"Overview of diagnostic layers (for {os.path.basename(db_names[db_idx+1])})")
             print_dl_metrics([
                 variant for variant in task.databases[db_idx + 1].diag_layers
                 if variant.short_name in task.diagnostic_layer_names
@@ -673,16 +691,17 @@ def run(args: argparse.Namespace) -> None:
                 break
             task.db_indicator_2 = db_idx + 1
 
-            print()
-            print(f"Changes in file '{os.path.basename(db_names[0])}")
-            print(f" (compared to '{os.path.basename(db_names[db_idx + 1])}')")
+            rich_print()
+            rich_print(f"Changes in file '{os.path.basename(db_names[0])}")
+            rich_print(f" (compared to '{os.path.basename(db_names[db_idx + 1])}')")
 
-            print()
-            print(f"Overview of diagnostic layers (for {os.path.basename(db_names[0])})")
+            rich_print()
+            rich_print(f"Overview of diagnostic layers (for {os.path.basename(db_names[0])})")
             print_dl_metrics(list(task.databases[0].diag_layers))
 
-            print()
-            print(f"Overview of diagnostic layers (for {os.path.basename(db_names[db_idx+1])})")
+            rich_print()
+            rich_print(
+                f"Overview of diagnostic layers (for {os.path.basename(db_names[db_idx+1])})")
             print_dl_metrics(list(task.databases[db_idx + 1].diag_layers))
 
             task.print_database_changes(
@@ -704,20 +723,20 @@ def run(args: argparse.Namespace) -> None:
 
         for name in args.variants:
             if name not in task.diagnostic_layer_names:
-                print(f"The variant '{name}' could not be found!")
+                rich_print(f"The variant '{name}' could not be found!")
                 return
 
-        print()
-        print(f"Overview of diagnostic layers: ")
+        rich_print()
+        rich_print(f"Overview of diagnostic layers: ")
         print_dl_metrics(task.diagnostic_layers)
 
         for db_idx, dl in enumerate(task.diagnostic_layers):
             if db_idx + 1 >= len(task.diagnostic_layers):
                 break
 
-            print()
-            print(f"Changes in diagnostic layer '{dl.short_name}' ({dl.variant_type.value})")
-            print(
+            rich_print()
+            rich_print(f"Changes in diagnostic layer '{dl.short_name}' ({dl.variant_type.value})")
+            rich_print(
                 f" (compared to '{task.diagnostic_layers[db_idx + 1].short_name}' ({task.diagnostic_layers[db_idx + 1].variant_type.value}))"
             )
             task.print_dl_changes(
@@ -725,4 +744,4 @@ def run(args: argparse.Namespace) -> None:
 
     else:
         # no databases & no variants specified
-        print("Please specify either a database or variant for a comparison")
+        rich_print("Please specify either a database or variant for a comparison")