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

odxtools/environmentdatadescription.py

@@ -1,6 +1,6 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Dict, List, Optional
+from typing import TYPE_CHECKING, Any, Dict, List, Optional, Tuple
 from xml.etree import ElementTree
 
 from .createsdgs import create_sdgs_from_et
@@ -11,7 +11,7 @@ from .encodestate import EncodeState
 from .environmentdata import EnvironmentData
 from .exceptions import DecodeError, EncodeError, odxrequire
 from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef
-from .odxtypes import odxstr_to_bool
+from .odxtypes import ParameterValue, odxstr_to_bool
 from .utils import dataclass_fields_asdict
 
 if TYPE_CHECKING:
@@ -93,7 +93,7 @@ class EnvironmentDataDescription(DopBase):
             for ed in self.env_datas:
                 ed._resolve_snrefs(diag_layer)
 
-    def convert_physical_to_bytes(self, physical_value, encode_state: EncodeState,
+    def convert_physical_to_bytes(self, physical_value: ParameterValue, encode_state: EncodeState,
                                   bit_position: int) -> bytes:
         """Convert the physical value into bytes.
 
@@ -102,7 +102,9 @@ class EnvironmentDataDescription(DopBase):
         """
         raise EncodeError("EnvironmentDataDescription DOPs cannot be encoded or decoded")
 
-    def convert_bytes_to_physical(self, decode_state: DecodeState, bit_position: int = 0):
+    def convert_bytes_to_physical(self,
+                                  decode_state: DecodeState,
+                                  bit_position: int = 0) -> Tuple[ParameterValue, int]:
         """Extract the bytes from the PDU and convert them to the physical value.
 
         Since environmental data is supposed to never appear on the

odxtools/field.py

@@ -2,11 +2,10 @@ from dataclasses import dataclass
 from typing import TYPE_CHECKING, List, Optional
 from xml.etree import ElementTree
 
-from .environmentdatadescription import EnvironmentDataDescription
 from .basicstructure import BasicStructure
 from .createsdgs import create_sdgs_from_et
 from .dopbase import DopBase
-from .element import IdentifiableElement
+from .environmentdatadescription import EnvironmentDataDescription
 from .exceptions import odxassert, odxrequire
 from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkRef
 from .odxtypes import odxstr_to_bool
@@ -67,12 +66,8 @@ class Field(DopBase):
         """may be a Structure or a env-data-desc"""
         return odxrequire(self._structure, "EnvironmentDataDescription is not supported")
 
-    @property
-    def bit_length(self):
-        return self.structure.bit_length
-
-    def convert_physical_to_internal(self, physical_value):
-        return self.structure.convert_physical_to_internal(physical_value)
+    def get_static_bit_length(self) -> Optional[int]:
+        return None
 
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
         """Recursively resolve any odxlinks references"""

odxtools/isotp_state_machine.py

@@ -5,7 +5,8 @@ import asyncio
 import re
 import sys
 from enum import IntEnum
-from typing import Iterable, List, Optional, Tuple, Union
+from io import TextIOBase
+from typing import AsyncGenerator, Iterable, List, Optional, TextIO, Tuple, Union
 
 import bitstruct
 import can
@@ -26,8 +27,10 @@ class IsoTp(IntEnum):
 
 class IsoTpStateMachine:
     can_normal_frame_re = re.compile(
-        "([a-zA-Z0-9_-]*) *([0-9A-Fa-f ]*) *\[[0-9]*\] *([ 0-9A-Fa-f]*)")
-    can_log_frame_re = re.compile("\([0-9.]*\) *([a-zA-Z0-9_-]*) ([0-9A-Fa-f]*)#([0-9A-Fa-f]*)")
+        "([a-zA-Z0-9_-]*) *([0-9A-Fa-f ]*) *\\[[0-9]+\\] *([ 0-9A-Fa-f]+)")
+    can_log_frame_re = re.compile("\\([0-9.]*\\) *([a-zA-Z0-9_-]*) ([0-9A-Fa-f]+)#([0-9A-Fa-f]+)")
+    can_fd_log_frame_re = re.compile(
+        "\\([0-9.]*\\) *([a-zA-Z0-9_-]*) ([0-9A-Fa-f]+)##[0-9A-Fa-f]([0-9A-Fa-f]+)")
 
     def __init__(self, can_rx_ids: Union[int, List[int]]):
         if isinstance(can_rx_ids, int):
@@ -103,7 +106,8 @@ class IsoTpStateMachine:
         else:
             self.on_frame_type_error(telegram_idx, frame_type)
 
-    async def read_telegrams(self, bus):
+    async def read_telegrams(self, bus: Union[can.Bus,
+                                              TextIO]) -> AsyncGenerator[Tuple[int, bytes], None]:
         """This is equivalent to the :py:meth:`file.readlines()` method, but
         it yields ISO-TP telegrams instead of lines.
 
@@ -112,12 +116,8 @@ class IsoTpStateMachine:
         :param bus: Input file or socket of can bus to read the can frames
         """
 
-        if hasattr(bus, "set_filters"):
-            # this is a bit of a hack: passing any object which
-            # exhibits a set_filters() method is assumed to be a can
-            # bus object.
-
-            # creat an "on receive" event for the can bus
+        if isinstance(bus, can.Bus):
+            # create an "on receive" event for the can bus
             rx_event = asyncio.Event()
             loop = asyncio.get_running_loop()
             loop.add_reader(bus, rx_event.set)
@@ -126,11 +126,13 @@ class IsoTpStateMachine:
                 await rx_event.wait()
 
                 msg = bus.recv()
+                if msg is None:
+                    continue
                 for tmp in self.decode_rx_frame(msg.arbitration_id, msg.data):
                     yield tmp
         else:
+            assert isinstance(bus, TextIOBase)
             # input is a file
-
             while bus:
                 cur_line = bus.readline()
                 if cur_line == "":
@@ -141,13 +143,14 @@ class IsoTpStateMachine:
                     frame_id = int(m.group(2), 16)
 
                     frame_data_formatted = m.group(3).strip()
-                    frame_data = bytearray(
-                        map(lambda x: int(x, 16), frame_data_formatted.split(" ")))
+                    frame_data = bytearray([int(x, 16) for x in frame_data_formatted.split(" ")])
 
                     for tmp in self.decode_rx_frame(frame_id, frame_data):
                         yield tmp
 
-                elif m := self.can_log_frame_re.match(cur_line.strip()):
+                elif (m := self.can_log_frame_re.match(
+                        cur_line.strip())) or (m := self.can_fd_log_frame_re.match(
+                            cur_line.strip())):
                     #frame_interface = m.group(2)
                     frame_id = int(m.group(2), 16)
 
@@ -156,7 +159,7 @@ class IsoTpStateMachine:
                         frame_data_formatted[i:i + 2]
                         for i in range(0, len(frame_data_formatted), 2)
                     ]
-                    frame_data = bytearray(map(lambda x: int(x, 16), frame_data_list))
+                    frame_data = bytearray([int(x, 16) for x in frame_data_list])
 
                     for tmp in self.decode_rx_frame(frame_id, frame_data):
                         yield tmp
@@ -166,14 +169,14 @@ class IsoTpStateMachine:
                         f"Warning: unrecognized frame format: '{cur_line.strip()}'",
                         file=sys.stderr)
 
-    def can_rx_id(self, telegram_idx):
+    def can_rx_id(self, telegram_idx: int) -> int:
         """Given a Telegram index, returns the CAN ID for receiving data.
 
         :raises IndexError: The telegram index is invalid.
         """
         return self._can_rx_ids[telegram_idx]
 
-    def telegram_data(self, telegram_idx):
+    def telegram_data(self, telegram_idx: int) -> Optional[bytes]:
         """Given a Telegram index, returns the data received for this telegram
         so far.
 
@@ -184,31 +187,32 @@ class IsoTpStateMachine:
     ##############
     # Callbacks
     ##############
-    def on_single_frame(self, telegram_idx, frame_payload):
-        """Method called when an ISO-TP message of type "single frame" has been received"""
+    def on_single_frame(self, telegram_idx: int, frame_payload: bytes) -> None:
+        """Callback method for when an ISO-TP message of type "single frame" has been received"""
         pass
 
-    def on_first_frame(self, telegram_idx, frame_payload):
-        """Method called when an ISO-TP message of type "first frame" has been received"""
+    def on_first_frame(self, telegram_idx: int, frame_payload: bytes) -> None:
+        """Callback method for when an ISO-TP message of type "first frame" has been received"""
         pass
 
-    def on_consecutive_frame(self, telegram_idx, segment_idx, frame_payload):
-        """Method called when an ISO-TP message of type "consecutive frame" has been received"""
+    def on_consecutive_frame(self, telegram_idx: int, segment_idx: int,
+                             frame_payload: bytes) -> None:
+        """Callback method for when an ISO-TP message of type "consecutive frame" has been received"""
         pass
 
-    def on_flow_control_frame(self, telegram_idx, flow_control_flag):
+    def on_flow_control_frame(self, telegram_idx: int, flow_control_flag: int) -> None:
         """Method called when an ISO-TP message of type "flow control frame" has been received"""
         pass
 
-    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:
         """Method called when a frame with an unexpected sequence index has been received"""
         pass
 
-    def on_frame_type_error(self, telegram_idx, frame_type):
+    def on_frame_type_error(self, telegram_idx: int, frame_type: int) -> None:
         """Method called when a frame exhibiting an unknown frame type has been received"""
         pass
 
-    def on_telegram_complete(self, telegram_idx, telegram_payload):
+    def on_telegram_complete(self, telegram_idx: int, telegram_payload: bytes) -> None:
         """Method called when an ISO-TP telegram has been fully received"""
         pass
 
@@ -219,7 +223,12 @@ class IsoTpActiveDecoder(IsoTpStateMachine):
     receive ISO-TP messages actively instead of just snooping in on
     other people's conversations."""
 
-    def __init__(self, can_bus, can_rx_ids, can_tx_ids, padding_size=0, padding_value=0xAA):
+    def __init__(self,
+                 can_bus: can.Bus,
+                 can_rx_ids: List[int],
+                 can_tx_ids: List[int],
+                 padding_size: int = 0,
+                 padding_value: int = 0xAA):
         self._can_bus = can_bus
 
         if isinstance(can_tx_ids, int):
@@ -231,14 +240,13 @@ class IsoTpActiveDecoder(IsoTpStateMachine):
 
         super().__init__(can_rx_ids)
 
-        assert isinstance(self._can_tx_ids, list)
         assert len(self._can_rx_ids) == len(self._can_tx_ids)
         assert set(self._can_rx_ids).isdisjoint(set(self._can_tx_ids))  # correct?
 
-        self._block_size = [None] * len(self._can_rx_ids)
-        self._frames_received = [None] * len(self._can_rx_ids)
+        self._block_size: List[Optional[int]] = [None] * len(self._can_rx_ids)
+        self._frames_received: List[Optional[int]] = [None] * len(self._can_rx_ids)
 
-    def can_tx_id(self, telegram_idx):
+    def can_tx_id(self, telegram_idx: int) -> int:
         """Given a Telegram index, returns the CAN ID for sending data.
 
         :raises TypeError: No transmission IDs specified (e.g.,
@@ -247,7 +255,7 @@ class IsoTpActiveDecoder(IsoTpStateMachine):
         """
         return self._can_tx_ids[telegram_idx]
 
-    def on_single_frame(self, telegram_idx, frame_payload):
+    def on_single_frame(self, telegram_idx: int, frame_payload: bytes) -> None:
         # send ACK
         #rx_id = self.can_rx_id(telegram_idx)
         tx_id = self.can_tx_id(telegram_idx)
@@ -266,7 +274,7 @@ class IsoTpActiveDecoder(IsoTpStateMachine):
 
         super().on_first_frame(telegram_idx, frame_payload)
 
-    def on_first_frame(self, telegram_idx, frame_payload):
+    def on_first_frame(self, telegram_idx: int, frame_payload: bytes) -> None:
         # send ACK
         #rx_id = self.can_rx_id(telegram_idx)
         tx_id = self.can_tx_id(telegram_idx)
@@ -288,12 +296,18 @@ class IsoTpActiveDecoder(IsoTpStateMachine):
 
         super().on_first_frame(telegram_idx, frame_payload)
 
-    def on_consecutive_frame(self, telegram_idx, segment_idx, frame_payload):
-        self._frames_received[telegram_idx] += 1
+    def on_consecutive_frame(self, telegram_idx: int, segment_idx: int,
+                             frame_payload: bytes) -> None:
+        num_received = self._frames_received[telegram_idx]
+        if num_received is None:
+            # consequtive frame received before a first frame.
+            # TODO (?): throw an exception
+            return
+        self._frames_received[telegram_idx] = num_received + 1
 
         # send new ACK if necessary
         block_size = self._block_size[telegram_idx]
-        if self._frames_received[telegram_idx] >= block_size:
+        if block_size is not None and num_received >= block_size:
             #rx_id = self.can_rx_id(telegram_idx)
             tx_id = self.can_tx_id(telegram_idx)
             min_separation_time = 0  # ms
@@ -310,7 +324,7 @@ class IsoTpActiveDecoder(IsoTpStateMachine):
 
         super().on_consecutive_frame(telegram_idx, segment_idx, frame_payload)
 
-    def _send_can_message(self, can_tx_id, payload):
+    def _send_can_message(self, can_tx_id: int, payload: bytes) -> None:
         if len(payload) < self._padding_size:
             payload = bytes(payload) + bytes([self._padding_value] *
                                              (self._padding_size - len(payload)))

odxtools/leadinglengthinfotype.py

@@ -1,19 +1,19 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import Any
+from typing import Any, Tuple
 
 from .decodestate import DecodeState
 from .diagcodedtype import DctType, DiagCodedType
 from .encodestate import EncodeState
 from .exceptions import odxassert, odxraise
-from .odxtypes import DataType
+from .odxtypes import AtomicOdxType, DataType
 
 
 @dataclass
 class LeadingLengthInfoType(DiagCodedType):
     bit_length: int
 
-    def __post_init__(self):
+    def __post_init__(self) -> None:
         odxassert(self.bit_length > 0,
                   "A Leading length info type with bit length == 0 does not make sense.")
         odxassert(
@@ -53,13 +53,15 @@ class LeadingLengthInfoType(DiagCodedType):
 
         return length_byte + value_byte
 
-    def convert_bytes_to_internal(self, decode_state: DecodeState, bit_position: int = 0):
+    def convert_bytes_to_internal(self,
+                                  decode_state: DecodeState,
+                                  bit_position: int = 0) -> Tuple[AtomicOdxType, int]:
         coded_message = decode_state.coded_message
 
         # Extract length of the parameter value
         byte_length, byte_position = self._extract_internal(
             coded_message=coded_message,
-            byte_position=decode_state.next_byte_position,
+            byte_position=decode_state.cursor_position,
             bit_position=bit_position,
             bit_length=self.bit_length,
             base_data_type=DataType.A_UINT32,  # length is an integer
@@ -72,7 +74,7 @@ class LeadingLengthInfoType(DiagCodedType):
         # Extract actual value
         # TODO: The returned value is None if the byte_length is 0. Maybe change it
         #       to some default value like an empty bytearray() or 0?
-        value, next_byte_position = self._extract_internal(
+        value, cursor_position = self._extract_internal(
             coded_message=coded_message,
             byte_position=byte_position,
             bit_position=0,
@@ -81,4 +83,4 @@ class LeadingLengthInfoType(DiagCodedType):
             is_highlow_byte_order=self.is_highlow_byte_order,
         )
 
-        return value, next_byte_position
+        return value, cursor_position

odxtools/load_file.py

@@ -1,9 +1,10 @@
 # SPDX-License-Identifier: MIT
+from .database import Database
 from .load_odx_d_file import load_odx_d_file
 from .load_pdx_file import load_pdx_file
 
 
-def load_file(file_name: str):
+def load_file(file_name: str) -> Database:
     if file_name.lower().endswith(".pdx"):
         return load_pdx_file(file_name)
     elif file_name.lower().endswith(".odx-d"):

odxtools/load_odx_d_file.py

@@ -1,9 +1,6 @@
 # SPDX-License-Identifier: MIT
 from .database import Database
-from .globals import logger
 
 
-def load_odx_d_file(odx_d_file_name: str):
-    container = Database(odx_d_file_name=odx_d_file_name)
-    logger.info(f"--- --- --- Done with parsing --- --- ---")
-    return container
+def load_odx_d_file(odx_d_file_name: str) -> Database:
+    return Database(odx_d_file_name=odx_d_file_name)

odxtools/load_pdx_file.py

@@ -2,11 +2,7 @@
 from zipfile import ZipFile
 
 from .database import Database
-from .globals import logger
 
 
-def load_pdx_file(pdx_file: str):
-    u = ZipFile(pdx_file)
-    container = Database(pdx_zip=u)
-    logger.info(f"--- --- --- Done with parsing --- --- ---")
-    return container
+def load_pdx_file(pdx_file: str) -> Database:
+    return Database(pdx_zip=ZipFile(pdx_file))

odxtools/message.py

@@ -1,12 +1,15 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Union
+
+from deprecation import deprecated
 
 from .odxtypes import ParameterValue, ParameterValueDict
 
 if TYPE_CHECKING:
     from .diagservice import DiagService
-    from .structure import Structure
+    from .request import Request
+    from .response import Response
 
 
 @dataclass
@@ -21,8 +24,13 @@ class Message:
 
     coded_message: bytes
     service: "DiagService"
-    structure: "Structure"
+    coding_object: Union["Request", "Response"]
     param_dict: ParameterValueDict
 
     def __getitem__(self, key: str) -> ParameterValue:
         return self.param_dict[key]
+
+    @property
+    @deprecated("use .coding_object")
+    def structure(self) -> Union["Request", "Response"]:
+        return self.coding_object