odxtools 5.3.1__py3-none-any.whl → 6.0.1__py3-none-any.whl

odxtools/cli/browse.py

@@ -2,16 +2,20 @@
 import argparse
 import logging
 import sys
-from typing import Dict, List, Union
+from typing import List, Optional, Union
 
 import PyInquirer.prompt as PI_prompt
 
 from ..database import Database
+from ..dataobjectproperty import DataObjectProperty
 from ..diaglayer import DiagLayer
 from ..diagservice import DiagService
-from ..odxtypes import DataType
+from ..exceptions import odxraise, odxrequire
+from ..odxtypes import AtomicOdxType, DataType, ParameterValueDict
+from ..parameters.matchingrequestparameter import MatchingRequestParameter
 from ..parameters.parameter import Parameter
 from ..parameters.parameterwithdop import ParameterWithDOP
+from ..parameters.valueparameter import ValueParameter
 from ..request import Request
 from ..response import Response
 from . import _parser_utils
@@ -20,7 +24,7 @@ from . import _parser_utils
 _odxtools_tool_name_ = "browse"
 
 
-def _convert_string_to_odx_type(string_value: str, odx_type: DataType):
+def _convert_string_to_odx_type(string_value: str, odx_type: DataType) -> AtomicOdxType:
     """Similar to odx_type.from_string(string_value) but more relaxed to parse user input"""
     if odx_type == DataType.A_UINT32:
         return int(string_value, 0)
@@ -30,57 +34,66 @@ def _convert_string_to_odx_type(string_value: str, odx_type: DataType):
         return odx_type.from_string(string_value)
 
 
-def _convert_string_to_bytes(string_value):
+def _convert_string_to_bytes(string_value: str) -> bytes:
     if all(len(x) <= 2 for x in string_value.split(" ")):
         return bytes(int(x, 16) for x in string_value.split(" ") if len(x) > 0)
     else:
         return int(string_value, 16).to_bytes((int(string_value, 16).bit_length() + 7) // 8, "big")
 
 
-def _validate_string_value(input, parameter):
-    if parameter.is_optional and input == "":
+def _validate_string_value(input: str, parameter: Parameter) -> bool:
+    if not parameter.is_required and input == "":
         return True
     elif isinstance(parameter, ParameterWithDOP):
         try:
-            val = _convert_string_to_odx_type(input, parameter.physical_type.base_data_type)
-        except:
+            phys_type = odxrequire(parameter.physical_type)
+            val = _convert_string_to_odx_type(input, phys_type.base_data_type)
+        except:  # noqa: E722
             return False
-        return parameter.dop.is_valid_physical_value(val)
+        dop = parameter.dop
+        if isinstance(dop, DataObjectProperty):
+            return dop.is_valid_physical_value(val)
+        else:
+            raise NotImplementedError("Validation of complex DOPs")
     else:
         logging.info("This value is not validated precisely: Parameter {parameter}")
         return input != ""
 
 
-def prompt_single_parameter_value(parameter):
-    if (not isinstance(parameter, ParameterWithDOP) or
-            parameter.get_valid_physical_values() is None or
-            parameter.get_valid_physical_values() is []):
-        param_prompt = [{
-            "type":
-                "input",
-            "name":
-                parameter.short_name,
-            "message":
-                f"Value for parameter '{parameter.short_name}' (Type: {parameter.physical_type.base_data_type})"
-                + (f"[optional]" if parameter.is_optional else ""),
-            # TODO: improve validation
-            "validate":
-                lambda x: _validate_string_value(x, parameter),
-            # TODO: do type conversion?
-            "filter":
-                lambda x: x
-            # x if x == "" or p.physical_type.base_data_type is None
-            # else _convert_string_to_odx_type(x, p.physical_type.base_data_type, param=p) # This does not work because the next parameter to be promted is used (for some reason?)
-        }]
-    else:
-        param_prompt = [{
-            "type": "list",
-            "name": parameter.short_name,
-            "message": f"Value for parameter '{parameter.short_name}'",
-            "choices": parameter.get_valid_physical_values(),
-        }]
+def prompt_single_parameter_value(parameter: Parameter) -> Optional[AtomicOdxType]:
+    if not isinstance(parameter, ValueParameter):
+        odxraise("Only the value of ValueParameters can be queried")
+    if parameter.physical_type is None:
+        odxraise("Only ValueParameters which define a physical data type can be queried")
+
+    # TODO: add valid choices for the parameter
+    #        "choices": parameter.get_valid_physical_values(),
+    param_prompt = [{
+        "type":
+            "input",
+        "name":
+            parameter.short_name,
+        "message":
+            f"Value for parameter '{parameter.short_name}' (Type: {parameter.physical_type.base_data_type})"
+            + (f"[optional]" if not parameter.is_required else ""),
+        # TODO: improve validation
+        "validate":
+            lambda x: _validate_string_value(x, parameter),
+        # TODO: do type conversion?
+        "filter":
+            lambda x: x
+        # x if x == "" or p.physical_type.base_data_type is None
+        # else _convert_string_to_odx_type(x, p.physical_type.base_data_type, param=p) # This does not work because the next parameter to be promted is used (for some reason?)
+    }]
+
+    if hasattr(parameter, "dop") and hasattr(parameter.dop, "compu_method") \
+       and hasattr(parameter.dop.compu_method, "get_scales"):
+        scales = parameter.dop.compu_method.get_scales()
+        choices = [scale.compu_const for scale in scales if scale is not None]
+        param_prompt[0]["choices"] = choices
+
     answer = PI_prompt.prompt(param_prompt)
-    if answer.get(parameter.short_name) == "" and parameter.is_optional:
+    if answer.get(parameter.short_name) == "" and not parameter.is_required:
         return None
     elif parameter.physical_type.base_data_type is not None:
         return _convert_string_to_odx_type(
@@ -92,21 +105,22 @@ def prompt_single_parameter_value(parameter):
         return answer.get(parameter.short_name)
 
 
-def encode_message_interactively(sub_service, ask_user_confirmation=False):
+def encode_message_interactively(sub_service: Union[Request, Response],
+                                 ask_user_confirmation: bool = False) -> None:
     if 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 k, param_or_dict in param_dict.items():
+    for param_or_dict in param_dict.values():
         if isinstance(param_or_dict, dict):
-            for k, param in param_or_dict.items():
-                if param.is_settable:
+            for param in param_or_dict.values():
+                if not isinstance(param_or_dict, dict) and param.is_settable:
                     exists_definable_param = True
         elif param_or_dict.is_settable:
             exists_definable_param = True
 
-    param_values = {}
+    param_values: ParameterValueDict = {}
     if exists_definable_param > 0:
         # Ask whether user wants to encode a message
         if ask_user_confirmation:
@@ -142,9 +156,9 @@ def encode_message_interactively(sub_service, ask_user_confirmation=False):
                 print(
                     f"The next {len(param_or_structure)} parameters belong to the structure '{key}'"
                 )
-                structure_param_values = {}
+                structure_param_values: ParameterValueDict = {}
                 for param_sn, param in param_or_structure.items():
-                    if param.is_settable:
+                    if not isinstance(param, dict) and param.is_settable:
                         val = prompt_single_parameter_value(param)
                         if val is not None:
                             structure_param_values[param_sn] = val
@@ -157,7 +171,7 @@ def encode_message_interactively(sub_service, ask_user_confirmation=False):
         if isinstance(sub_service, Response):
             payload = sub_service.encode(coded_request=answered_request, **param_values)
         else:
-            payload = sub_service.encode(**param_values)
+            payload = sub_service.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()
@@ -166,26 +180,28 @@ def encode_message_interactively(sub_service, ask_user_confirmation=False):
 
 def encode_message_from_string_values(
     sub_service: Union[Request, Response],
-    parameter_values: Dict[str, Union[str, Dict[str, str]]] = {},
-):
+    parameter_values: Optional[ParameterValueDict] = None,
+) -> None:
+    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
     missing_parameter_names = []
-    for parameter_sn, parameter in param_dict.items():
-        if isinstance(parameter, dict):
-            # parameter_value refers to a structure (represented as dict of params)
-            for simple_param_sn, simple_param in parameter.items():
-                structured_value = parameter_values.get(parameter_sn)
+    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"{parameter_sn} :: {simple_param_sn}")
+                    missing_parameter_names.append(f"{param_sn} :: {simple_param_sn}")
         else:
-            if parameter.is_required and parameter_values.get(parameter_sn) is None:
-                missing_parameter_names.append(parameter_sn)
+            if param.is_required and parameter_values.get(param_sn) is None:
+                missing_parameter_names.append(param_sn)
 
     if len(missing_parameter_names) > 0:
         print("The following parameters are required but missing!")
@@ -194,31 +210,36 @@ def encode_message_from_string_values(
 
     # Request values for parameters
     for parameter_sn, parameter_value in parameter_values.items():
+        parameter = param_dict.get(parameter_sn)
+        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)
             typed_dict = parameter_value.copy()
-            for simple_param_sn, simple_val in parameter_value.items():
-                try:
-                    parameter = param_dict[parameter_sn][simple_param_sn]  # type: ignore
-                except:
-                    print(f"I don't know the parameter {simple_param_sn}")
+            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}")
+                    continue
+                if not isinstance(simple_param_val, str):
+                    print(f"The value specified for parameter {simple_param_sn} is not a string")
                     continue
 
                 typed_dict[simple_param_sn] = _convert_string_to_odx_type(
-                    simple_val,
-                    parameter.physical_type.base_data_type  # type: ignore[union-attr]
+                    simple_param_val,
+                    simple_parameter.physical_type.base_data_type  # type: ignore[union-attr]
                 )
                 parameter_values[parameter_sn] = typed_dict
         else:
-            try:
-                parameter = param_dict[parameter_sn]
-            except:
-                print(f"I don't know the parameter {parameter_sn}")
-                continue
-
             assert isinstance(parameter, Parameter)
 
-            if parameter.parameter_type != "MATCHING-REQUEST-PARAM":
+            if not isinstance(parameter_value, str):
+                print(f"Value for parameter {parameter_sn} is not a string")
+                continue
+
+            if not isinstance(parameter, MatchingRequestParameter):
                 parameter_values[parameter_sn] = _convert_string_to_odx_type(
                     parameter_value,
                     parameter.physical_type.base_data_type,  # type: ignore[attr-defined]
@@ -231,7 +252,7 @@ def encode_message_from_string_values(
     print(f"Message payload: 0x{bytes(payload).hex()}")
 
 
-def browse(odxdb: Database):
+def browse(odxdb: Database) -> None:
     if 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]
@@ -323,7 +344,7 @@ def browse(odxdb: Database):
             encode_message_interactively(sub_service, ask_user_confirmation=True)
 
 
-def add_subparser(subparsers):
+def add_subparser(subparsers: "argparse._SubParsersAction") -> None:
     # Browse interactively to avoid spamming the console.
     parser = subparsers.add_parser(
         "browse",
@@ -335,6 +356,6 @@ def add_subparser(subparsers):
     _parser_utils.add_pdx_argument(parser)
 
 
-def run(args):
+def run(args: argparse.Namespace) -> None:
     odxdb = _parser_utils.load_file(args)
     browse(odxdb)

odxtools/cli/find.py

@@ -1,46 +1,36 @@
 # SPDX-License-Identifier: MIT
 import argparse
-from typing import Dict, List
+from typing import Dict, List, Optional
 
 from ..database import Database
 from ..diagservice import DiagService
+from ..exceptions import odxraise
+from ..odxtypes import ParameterValue
 from ..singleecujob import SingleEcuJob
 from . import _parser_utils
-from ._print_utils import print_diagnostic_service
 
 # name of the tool
 _odxtools_tool_name_ = "find"
 
 
-def get_display_value(v, _param):
-    import binascii
-
+def get_display_value(v: ParameterValue) -> str:
     if isinstance(v, bytes):
-        return binascii.hexlify(v, " ", 1).decode("utf-8")
+        return v.hex(" ")
     elif isinstance(v, int):
-        return f"{v} ({hex(v)})"
+        return f"{v} (0x{v:x})"
     else:
-        return v
-
-
-def print_decoded_message(service: DiagService, message: bytes):
-    decoded = service.decode_message(message)
-    print(f"\nDecoded {decoded.structure}:")
-    for k, v in decoded.param_dict.items():
-        param = decoded.structure.parameter_dict()[k]
-        print(f"\t{k}: {get_display_value(v, param)}")
-    pass
+        return str(v)
 
 
 def print_summary(
     odxdb: Database,
-    ecu_variants=None,
-    data=None,
-    service_names=None,
-    decode=False,
-    print_params=False,
-    allow_unknown_bit_lengths=False,
-):
+    ecu_variants: Optional[List[str]] = None,
+    data: bytes = b'',
+    service_names: Optional[List[str]] = None,
+    decode: bool = False,
+    print_params: bool = False,
+    allow_unknown_bit_lengths: bool = False,
+) -> None:
     ecu_names = ecu_variants if ecu_variants else [ecu.short_name for ecu in odxdb.ecus]
     services: Dict[DiagService, List[str]] = {}
     for ecu_name in ecu_names:
@@ -63,31 +53,31 @@ def print_summary(
                         ecu_names.append(ecu_name)
                         services[service] = ecu_names
 
+    print(f"Binary data: {data.hex(' ')}")
     for service, ecu_names in services.items():
-        display_names = ", ".join(ecu_names)
-        filler = str.ljust("", len(display_names), "=")
-        print(f"\n{filler}")
-        print(f"{', '.join(ecu_names)}")
-        print(f"{filler}\n\n")
         if isinstance(service, DiagService):
-            print_diagnostic_service(
-                service,
-                print_params=print_params,
-                allow_unknown_bit_lengths=allow_unknown_bit_lengths,
-                print_pre_condition_states=True,
-                print_state_transitions=True,
-                print_audiences=True,
+            print(
+                f"Decoded by service '{service.short_name}' (decoding ECUs: {', '.join(ecu_names)})"
             )
         elif isinstance(service, SingleEcuJob):
-            print(f"SingleEcuJob: {service.odx_id}")
+            print(
+                f"Decoded by single ecu job '{service.short_name}' (decoding ECUs: {', '.join(ecu_names)})"
+            )
         else:
-            print(f"Unknown service: {service}")
+            print(f"Decoded by unknown diagnostic communication: '{service.short_name}' "
+                  f"(decoding ECUs: {', '.join(ecu_names)})")
 
         if decode:
-            print_decoded_message(service, data)
+            if data is None:
+                odxraise("Data is required for decoding")
 
+            decoded = service.decode_message(data)
+            print(f"Decoded data:")
+            for param_name, param_value in decoded.param_dict.items():
+                print(f"  {param_name}={get_display_value(param_value)}")
 
-def add_subparser(subparsers):
+
+def add_subparser(subparsers: "argparse._SubParsersAction") -> None:
     parser = subparsers.add_parser(
         "find",
         description="\n".join([
@@ -111,7 +101,7 @@ def add_subparser(subparsers):
     parser.add_argument(
         "-v",
         "--variants",
-        nargs="+",
+        nargs=1,
         metavar="VARIANT",
         required=False,
         help="Specifies which ecu variants should be included.",
@@ -121,21 +111,20 @@ def add_subparser(subparsers):
     parser.add_argument(
         "-d",
         "--data",
-        nargs="*",
+        nargs=1,
         default=None,
         metavar="DATA",
-        required=False,
+        required=True,
         help="Print a list of diagnostic services associated with the hex request.",
     )
 
     parser.add_argument(
         "-D",
         "--decode",
-        nargs="*",
-        default=None,
-        metavar="DECODE",
+        default=False,
+        action="store_true",
         required=False,
-        help="Print a list of diagnostic services associated with the hex request and decode the request.",
+        help="Decode the specified hex request.",
     )
 
     parser.add_argument(
@@ -165,21 +154,15 @@ def add_subparser(subparsers):
     )
 
 
-def hex_to_binary(data):
-    import binascii
+def hex_to_binary(data_str: str) -> bytes:
+    return bytes.fromhex(data_str)
 
-    return binascii.unhexlify("".join(data).replace(" ", ""))
 
-
-def run(args):
+def run(args: argparse.Namespace) -> None:
     odxdb = _parser_utils.load_file(args)
-
-    variants = args.variants if args.variants else None
-
-    data = (
-        hex_to_binary(args.data)
-        if args.data else hex_to_binary(args.decode) if args.decode else None)
-    decode = True if args.decode else False
+    variants = args.variants
+    data = bytes.fromhex(args.data[0])
+    decode = args.decode
 
     print_summary(
         odxdb,

odxtools/cli/list.py

@@ -1,6 +1,6 @@
 # SPDX-License-Identifier: MIT
 import argparse
-from typing import List, Union
+from typing import Callable, List, Optional, Union
 
 from ..database import Database
 from ..diaglayer import DiagLayer
@@ -15,18 +15,18 @@ _odxtools_tool_name_ = "list"
 
 def print_summary(
     odxdb: Database,
-    print_global_negative_responses=False,
-    print_services=False,
-    print_dops=False,
-    print_params=False,
-    print_com_params=False,
-    print_pre_condition_states=False,
-    print_state_transitions=False,
-    print_audiences=False,
-    allow_unknown_bit_lengths=False,
-    variants=None,
-    service_filter=lambda x: True,
-):
+    print_global_negative_responses: bool = False,
+    print_services: bool = False,
+    print_dops: bool = False,
+    print_params: bool = False,
+    print_com_params: 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[[Union[DiagService, SingleEcuJob]], bool] = lambda x: True,
+) -> None:
 
     diag_layer_names = variants if variants else [dl.short_name for dl in odxdb.diag_layers]
 
@@ -97,7 +97,7 @@ def print_summary(
                 print(f"  {com_param.short_name}: {com_param.value}")
 
 
-def add_subparser(subparsers):
+def add_subparser(subparsers: "argparse._SubParsersAction") -> None:
     parser = subparsers.add_parser(
         "list",
         description="\n".join([
@@ -179,16 +179,20 @@ def add_subparser(subparsers):
     )
 
 
-def run(args):
+def run(args: argparse.Namespace) -> None:
     odxdb = _parser_utils.load_file(args)
 
+    def service_filter(s: Union[DiagService, SingleEcuJob]) -> bool:
+        if args.services and len(args.services) > 0:
+            return s.short_name in args.services
+        return True
+
     variants = args.variants if args.variants else None
     print_summary(
         odxdb,
         print_global_negative_responses=args.all or args.global_negative_responses,
         print_services=args.all or args.params or args.services is not None,
-        service_filter=(lambda s: s.short_name in args.services
-                        if args.services and len(args.services) > 0 else lambda s: True),
+        service_filter=service_filter,
         print_dops=args.all or args.dops,
         variants=None if variants == "all" else variants,
         print_params=args.all or args.params,

odxtools/cli/snoop.py

@@ -4,12 +4,14 @@
 import argparse
 import asyncio
 import sys
+from typing import Any, Type
 
 import can
 
-import odxtools
 import odxtools.isotp_state_machine as ism
 import odxtools.uds as uds
+from odxtools.exceptions import DecodeError
+from odxtools.isotp_state_machine import IsoTpStateMachine
 
 from . import _parser_utils
 
@@ -23,7 +25,7 @@ ecu_rx_id = None
 ecu_tx_id = None
 
 
-def handle_telegram(telegram_id, payload):
+def handle_telegram(telegram_id: int, payload: bytes) -> None:
     global odx_diag_layer
     global last_request
 
@@ -36,7 +38,7 @@ def handle_telegram(telegram_id, payload):
         if last_request is not None:
             try:
                 decoded_message = odx_diag_layer.decode_response(payload, last_request)[0]
-            except odxtools.DecodeError:
+            except DecodeError:
                 pass
 
         if decoded_message is not None:
@@ -52,7 +54,7 @@ def handle_telegram(telegram_id, payload):
         try:
             decoded_message = odx_diag_layer.decode(payload)[0]
             last_request = payload
-        except odxtools.DecodeError:
+        except DecodeError:
             last_request = None
 
     if decoded_message:
@@ -60,21 +62,22 @@ def handle_telegram(telegram_id, payload):
     else:
         print(f"Tester: "
               f"{payload.hex()} "
-              f"({payload}, {len(payload)} bytes)")
+              f"({payload!r}, {len(payload)} bytes)")
 
 
-def init_verbose_state_machine(BaseClass, *args, **kwargs):
+def init_verbose_state_machine(BaseClass: Type[IsoTpStateMachine], *args: Any,
+                               **kwargs: Any) -> IsoTpStateMachine:
 
-    class InformativeIsoTpDecoder(BaseClass):
+    class InformativeIsoTpDecoder(BaseClass):  # type: ignore[valid-type, misc]
 
-        def on_sequence_error(self, telegram_idx, expected_idx, rx_idx):
+        def on_sequence_error(self, telegram_idx: int, expected_idx: int, rx_idx: int) -> None:
             rx_can_id = self.can_rx_id(telegram_idx)
             print(f"Sequence error for ID 0x{rx_can_id:x}: "
                   f"Received sequence number {rx_idx} but expected {expected_idx}")
 
-            super(BaseClass, self).on_sequence_error(telegram_idx, expected_idx, rx_idx)
+            super().on_sequence_error(telegram_idx, expected_idx, rx_idx)
 
-        def on_frame_type_error(self, telegram_idx, frame_type):
+        def on_frame_type_error(self, telegram_idx: int, frame_type: int) -> None:
             rx_can_id = self.can_rx_id(telegram_idx)
 
             print(f"Invalid ISO-TP frame for CAN ID 0x{rx_can_id:x}: {frame_type}")
@@ -82,7 +85,7 @@ def init_verbose_state_machine(BaseClass, *args, **kwargs):
     return InformativeIsoTpDecoder(*args, **kwargs)
 
 
-async def active_main(args):
+async def active_main(args: argparse.Namespace) -> None:
     global ecu_rx_id, ecu_tx_id
 
     can_bus = can.Bus(channel=args.channel, bustype="socketcan")
@@ -102,7 +105,7 @@ async def active_main(args):
         handle_telegram(telegram_id, payload)
 
 
-async def passive_main(args):
+async def passive_main(args: argparse.Namespace) -> None:
     global ecu_rx_id, ecu_tx_id
 
     ecu_rx_id = int(args.rx, 0)
@@ -124,7 +127,7 @@ async def passive_main(args):
             handle_telegram(telegram_id, payload)
 
 
-def add_cli_arguments(parser):
+def add_cli_arguments(parser: argparse.ArgumentParser) -> None:
     parser.add_argument(
         "--active",
         "-a",
@@ -172,7 +175,7 @@ def add_cli_arguments(parser):
     _parser_utils.add_pdx_argument(parser)
 
 
-def add_subparser(subparsers):
+def add_subparser(subparsers: "argparse._SubParsersAction") -> None:
     parser = subparsers.add_parser(
         "snoop",
         description="Live decoding of a diagnostic session.",
@@ -182,7 +185,7 @@ def add_subparser(subparsers):
     add_cli_arguments(parser)
 
 
-def run(args, odx_database=None):
+def run(args: argparse.Namespace) -> None:
     global odx_diag_layer
     odx_database = _parser_utils.load_file(args)
 
@@ -238,6 +241,4 @@ if __name__ == "__main__":
 
     args = parser.parse_args()  # deals with the help message handling
 
-    odx_database = odxtools.load_pdx_file(args.pdx_file)
-
-    run(args, odx_database)
+    run(args)