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

odxtools/__init__.py

@@ -71,7 +71,7 @@ from .write_pdx_file import write_pdx_file
 __author__ = "Katrin Bauer"
 
 
-def _main():
+def _main() -> None:
     # Command line tool
     from .cli import main as _main
 

odxtools/basicstructure.py

@@ -1,73 +1,64 @@
 # SPDX-License-Identifier: MIT
-import math
 import warnings
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, List, Optional, Tuple, Union
+from typing import TYPE_CHECKING, Any, Dict, List, Optional, Tuple
 
 from .dataobjectproperty import DataObjectProperty
 from .decodestate import DecodeState
 from .dopbase import DopBase
 from .encodestate import EncodeState
-from .exceptions import DecodeError, EncodeError, OdxWarning, odxassert
+from .exceptions import DecodeError, EncodeError, OdxWarning, odxassert, odxraise
 from .nameditemlist import NamedItemList
-from .odxlink import OdxLinkDatabase
-from .odxtypes import ParameterDict, ParameterValueDict
+from .odxlink import OdxLinkDatabase, OdxLinkId
+from .odxtypes import ParameterDict, ParameterValue, ParameterValueDict
 from .parameters.codedconstparameter import CodedConstParameter
 from .parameters.lengthkeyparameter import LengthKeyParameter
 from .parameters.matchingrequestparameter import MatchingRequestParameter
+from .parameters.nrcconstparameter import NrcConstParameter
 from .parameters.parameter import Parameter
 from .parameters.parameterwithdop import ParameterWithDOP
+from .parameters.physicalconstantparameter import PhysicalConstantParameter
 from .parameters.tablekeyparameter import TableKeyParameter
 from .parameters.valueparameter import ValueParameter
 
 if TYPE_CHECKING:
     from .diaglayer import DiagLayer
-    from .endofpdufield import EndOfPduField
 
 
 @dataclass
 class BasicStructure(DopBase):
-    parameters: NamedItemList[Union[Parameter, "EndOfPduField"]]
+    parameters: NamedItemList[Parameter]
     byte_size: Optional[int]
 
-    @property
-    def bit_length(self) -> Optional[int]:
+    def get_static_bit_length(self) -> Optional[int]:
         # Explicit size was specified
         if self.byte_size:
             return 8 * self.byte_size
 
-        if all(p.bit_length is not None for p in self.parameters):
-            offset = 0
-            length = 0
-            for param in self.parameters:
-                if isinstance(param, ValueParameter) and hasattr(param.dop, "min_number_of_items"):
-                    # The param repeats itself, making bit_length calculation invalid
-                    # Temporary workaround
-                    # Can not import EndOfPduField to check on its type due to circular dependency
-                    return None
-
-                if param.byte_position is not None:
-                    bit_position_int = param.bit_position if param.bit_position is not None else 0
-                    byte_position_int = (
-                        param.byte_position if param.byte_position is not None else 0)
-                    offset = byte_position_int * 8 + bit_position_int
-                offset += param.bit_length
-
-                length = max(length, offset)
-
-            # Round up to account for padding bits
-            return math.ceil(length / 8) * 8
-
-        # We were not able to calculate a static bit length
-        return None
-
-    def coded_const_prefix(self, request_prefix: bytes = bytes()) -> bytes:
-        prefix = bytes()
+        cursor = 0
+        length = 0
+        for param in self.parameters:
+            param_bit_length = param.get_static_bit_length()
+            if param_bit_length is None:
+                # We were not able to calculate a static bit length
+                return None
+            elif param.byte_position is not None:
+                bit_pos = param.bit_position or 0
+                byte_pos = param.byte_position or 0
+                cursor = byte_pos * 8 + bit_pos
+
+            cursor += param_bit_length
+            length = max(length, cursor)
+
+        # Round up to account for padding bits
+        return ((length + 7) // 8) * 8
+
+    def coded_const_prefix(self, request_prefix: bytes = b'') -> bytes:
+        prefix = b''
         encode_state = EncodeState(prefix, parameter_values={}, triggering_request=request_prefix)
         for p in self.parameters:
-            if isinstance(p, CodedConstParameter) and p.bit_length % 8 == 0:
-                encode_state.coded_message = p.encode_into_pdu(encode_state)
-            elif isinstance(p, MatchingRequestParameter):
+            if isinstance(p, (CodedConstParameter, NrcConstParameter, MatchingRequestParameter,
+                              PhysicalConstantParameter)):
                 encode_state.coded_message = p.encode_into_pdu(encode_state)
             else:
                 break
@@ -80,7 +71,7 @@ class BasicStructure(DopBase):
         return [p for p in self.parameters if p.is_required]
 
     @property
-    def free_parameters(self) -> List[Union[Parameter, "EndOfPduField"]]:  # type: ignore
+    def free_parameters(self) -> List[Parameter]:
         """Return the list of parameters which can be freely specified by
         the user when encoding the structure.
 
@@ -89,17 +80,9 @@ class BasicStructure(DopBase):
         the corresponding request (in the case of responses).
 
         """
-        from .endofpdufield import EndOfPduField
-
-        result: List[Union[Parameter, EndOfPduField]] = []
+        result: List[Parameter] = []
         for param in self.parameters:
-            if isinstance(param, EndOfPduField):
-                result.append(param)
-                continue
-            elif not param.is_required:
-                continue
-            # The user cannot specify MatchingRequestParameters freely!
-            elif isinstance(param, MatchingRequestParameter):
+            if not param.is_settable:
                 continue
             result.append(param)
 
@@ -114,13 +97,18 @@ class BasicStructure(DopBase):
         print(parameter_info(self.free_parameters), end="")
 
     def convert_physical_to_internal(self,
-                                     param_values: ParameterValueDict,
+                                     param_value: ParameterValue,
                                      triggering_coded_request: Optional[bytes],
                                      is_end_of_pdu: bool = True) -> bytes:
 
+        if not isinstance(param_value, dict):
+            raise EncodeError(
+                f"Expected a dictionary for the values of structure {self.short_name}, "
+                f"got {type(param_value)}")
+
         encode_state = EncodeState(
-            bytes(),
-            dict(param_values),
+            b'',
+            dict(param_value),
             triggering_request=triggering_coded_request,
             is_end_of_pdu=False,
         )
@@ -161,11 +149,11 @@ class BasicStructure(DopBase):
             # We definitely broke something if we didn't respect the explicit byte_size
             odxassert(
                 len(coded_message) == self.byte_size,
-                self._get_encode_error_str("was", coded_message, self.byte_size * 8))
+                "Verification of coded message {coded_message.hex()} failed: Incorrect size.")
             # No need to check further
             return
 
-        bit_length = self.bit_length
+        bit_length = self.get_static_bit_length()
 
         if bit_length is None:
             # Nothing to check
@@ -176,19 +164,18 @@ class BasicStructure(DopBase):
             # but it could be that bit_length was mis calculated and not the actual bytes are wrong
             # Could happen with overlapping parameters and parameters with gaps
             warnings.warn(
-                self._get_encode_error_str("may have been", coded_message, bit_length), OdxWarning)
-
-    def _get_encode_error_str(self, verb: str, coded_message: bytes, bit_length: int) -> str:
-        return str(f"Structure {self.short_name} {verb} encoded incorrectly:" +
-                   f" actual length is {len(coded_message)}," +
-                   f" computed byte length is {bit_length // 8}," +
-                   f" computed_rpc is {coded_message.hex()}\n" +
-                   "\n".join(self.__message_format_lines()))
+                "Verification of coded message {coded_message.hex()} possibly failed: Size may be incorrect.",
+                OdxWarning,
+                stacklevel=1)
 
     def convert_physical_to_bytes(self,
-                                  param_values: ParameterValueDict,
+                                  param_values: ParameterValue,
                                   encode_state: EncodeState,
                                   bit_position: int = 0) -> bytes:
+        if not isinstance(param_values, dict):
+            raise EncodeError(
+                f"Expected a dictionary for the values of structure {self.short_name}, "
+                f"got {type(param_values)}")
         if bit_position != 0:
             raise EncodeError("Structures must be aligned, i.e. bit_position=0, but "
                               f"{self.short_name} was passed the bit position {bit_position}")
@@ -200,27 +187,27 @@ class BasicStructure(DopBase):
 
     def convert_bytes_to_physical(self,
                                   decode_state: DecodeState,
-                                  bit_position: int = 0) -> Tuple[ParameterValueDict, int]:
+                                  bit_position: int = 0) -> Tuple[ParameterValue, int]:
         if bit_position != 0:
             raise DecodeError("Structures must be aligned, i.e. bit_position=0, but "
                               f"{self.short_name} was passed the bit position {bit_position}")
-        byte_code = decode_state.coded_message[decode_state.next_byte_position:]
+        byte_code = decode_state.coded_message[decode_state.cursor_position:]
         inner_decode_state = DecodeState(
-            coded_message=byte_code, parameter_values={}, next_byte_position=0)
+            coded_message=byte_code, parameter_values={}, cursor_position=0)
 
         for parameter in self.parameters:
-            value, next_byte_position = parameter.decode_from_pdu(inner_decode_state)
+            value, cursor_position = parameter.decode_from_pdu(inner_decode_state)
 
             inner_decode_state.parameter_values[parameter.short_name] = value
             inner_decode_state = DecodeState(
                 coded_message=byte_code,
                 parameter_values=inner_decode_state.parameter_values,
-                next_byte_position=max(inner_decode_state.next_byte_position, next_byte_position),
+                cursor_position=max(inner_decode_state.cursor_position, cursor_position),
             )
 
-        return inner_decode_state.parameter_values, decode_state.next_byte_position + inner_decode_state.next_byte_position
+        return inner_decode_state.parameter_values, decode_state.cursor_position + inner_decode_state.cursor_position
 
-    def encode(self, coded_request: Optional[bytes] = None, **params) -> bytes:
+    def encode(self, coded_request: Optional[bytes] = None, **params: ParameterValue) -> bytes:
         """
         Composes an UDS message as bytes for this service.
         Parameters:
@@ -237,13 +224,17 @@ class BasicStructure(DopBase):
 
     def decode(self, message: bytes) -> ParameterValueDict:
         # dummy decode state to be passed to convert_bytes_to_physical
-        decode_state = DecodeState(parameter_values={}, coded_message=message, next_byte_position=0)
-        param_values, next_byte_position = self.convert_bytes_to_physical(decode_state)
-        if len(message) != next_byte_position:
+        decode_state = DecodeState(parameter_values={}, coded_message=message, cursor_position=0)
+        param_values, cursor_position = self.convert_bytes_to_physical(decode_state)
+        if not isinstance(param_values, dict):
+            odxraise(f"Decoding a structure must result in a dictionary of parameter "
+                     f"values (is {type(param_values)})")
+        if len(message) != cursor_position:
             warnings.warn(
                 f"The message {message.hex()} is longer than could be parsed."
-                f" Expected {next_byte_position} but got {len(message)}.",
+                f" Expected {cursor_position} but got {len(message)}.",
                 DecodeError,
+                stacklevel=1,
             )
         return param_values
 
@@ -270,7 +261,7 @@ class BasicStructure(DopBase):
         })
         return param_dict
 
-    def _build_odxlinks(self):
+    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
         result = super()._build_odxlinks()
 
         for p in self.parameters:
@@ -292,15 +283,11 @@ class BasicStructure(DopBase):
         for p in self.parameters:
             p._resolve_snrefs(diag_layer)
 
-    def __message_format_lines(self, allow_unknown_lengths: bool = False) -> List[str]:
+    def _message_format_lines(self, allow_unknown_lengths: bool = False) -> List[str]:
         # sort parameters
         sorted_params: list = list(self.parameters)  # copy list
 
-        def param_sort_key(param: Union[Parameter, "EndOfPduField"]) -> Tuple[int, int]:
-            if not isinstance(param, Parameter):
-                # -> EndOfPduField should come last!
-                return (1000 * 1000, 0)
-
+        def param_sort_key(param: Parameter) -> Tuple[int, int]:
             byte_position_int = param.byte_position if param.byte_position is not None else 0
             bit_position_int = param.bit_position if param.bit_position is not None else 0
             return (byte_position_int, 8 - bit_position_int)
@@ -310,8 +297,8 @@ class BasicStructure(DopBase):
         # replace structure parameters by their sub parameters
         params: List[Parameter] = []
         for p in sorted_params:
-            if isinstance(p, ValueParameter) and isinstance(p.dop, BasicStructure):
-                params += p.dop.parameters
+            if isinstance(p, ValueParameter) and isinstance(p._dop, BasicStructure):
+                params += p._dop.parameters
             else:
                 params.append(p)
 
@@ -358,14 +345,12 @@ class BasicStructure(DopBase):
                     # END-OF-PDU fields do not exhibit a fixed bit
                     # length, so they need special treatment here
                     dct = None
-                    if hasattr(params[param_idx], "dop"):
-                        dop = params[param_idx].dop  # type: ignore
+                    if hasattr(params[param_idx], "_dop"):
+                        dop = params[param_idx]._dop  # type: ignore[attr-defined]
                         if hasattr(dop, "diag_coded_type"):
                             dct = dop.diag_coded_type
 
-                    bit_length = None
-                    if hasattr(params[param_idx], "bit_length"):
-                        bit_length = params[param_idx].bit_length
+                    bit_length = params[param_idx].get_static_bit_length()
 
                     if dct is not None and dct.dct_type == "MIN-MAX-LENGTH-TYPE":
                         name = params[param_idx].short_name + " ("
@@ -434,12 +419,12 @@ class BasicStructure(DopBase):
         else:
             return []
 
-    def print_message_format(self, indent: int = 5, allow_unknown_lengths=False):
+    def print_message_format(self, indent: int = 5, allow_unknown_lengths: bool = False) -> None:
         """
         Print a description of the message format to `stdout`.
         """
 
-        message_as_lines = self.__message_format_lines(allow_unknown_lengths=allow_unknown_lengths)
+        message_as_lines = self._message_format_lines(allow_unknown_lengths=allow_unknown_lengths)
         if message_as_lines is not None:
             print(f"{indent * ' '}" + f"\n{indent * ' '}".join(message_as_lines))
         else:

odxtools/cli/_parser_utils.py

@@ -1,17 +1,20 @@
 #! /usr/bin/python3
 #
 # SPDX-License-Identifier: MIT
+import argparse
+
+from ..database import Database
 from ..load_file import load_file as _load_file
 
 
-def add_pdx_argument(parser):
-    parser.add_argument("pdx_file", metavar="PDX_FILE", help="path to the .pdx file")
-    # parser.add_argument("pdx_files", metavar="PDX_FILES", nargs="+", help="PDX descriptions of all ECUs which shall be analyzed")
+def add_pdx_argument(parser: argparse.ArgumentParser, is_optional: bool = False) -> None:
+    parser.add_argument(
+        "pdx_file",
+        help="Location of the .pdx file",
+        nargs="?" if is_optional else 1,
+        metavar="PDX_FILE")
 
 
-def load_file(args):
-    db_file_name = args.pdx_file
-    odxdb = None
-    if db_file_name is not None:
-        odxdb = _load_file(db_file_name)
-    return odxdb
+def load_file(args: argparse.Namespace) -> Database:
+    pdx_file_name = args.pdx_file if isinstance(args.pdx_file, str) else args.pdx_file[0]
+    return _load_file(pdx_file_name)

odxtools/cli/_print_utils.py

@@ -6,7 +6,7 @@ import markdownify
 from ..diagservice import DiagService
 
 
-def format_desc(desc, ident=0):
+def format_desc(desc: str, ident: int = 0) -> str:
     # Collapse whitespaces
     desc = re.sub(r"\s+", " ", desc)
     # Covert XHTML to Markdown
@@ -21,12 +21,12 @@ def format_desc(desc, ident=0):
 
 def print_diagnostic_service(
     service: DiagService,
-    print_params=False,
-    print_pre_condition_states=False,
-    print_state_transitions=False,
-    print_audiences=False,
-    allow_unknown_bit_lengths=False,
-):
+    print_params: bool = False,
+    print_pre_condition_states: bool = False,
+    print_state_transitions: bool = False,
+    print_audiences: bool = False,
+    allow_unknown_bit_lengths: bool = False,
+) -> None:
     print(f" {service.short_name} <ID: {service.odx_id}>")
 
     if service.description: