pyxcp 0.23.8__cp313-cp313-macosx_11_0_arm64.whl → 0.25.7__cp313-cp313-macosx_11_0_arm64.whl

pyxcp/tests/test_transport.py

@@ -1,55 +1,151 @@
 from unittest import mock
 
 import pytest
+import serial
+from can.bus import BusABC
 
 import pyxcp.transport.base as tr
 
 
+def create_mock_serial():
+    """Create a mock serial port for testing."""
+    mock_serial = mock.MagicMock(spec=serial.Serial)
+    mock_serial.portstr = "MOCK_PORT"
+    mock_serial.in_waiting = 0
+    mock_serial.read.return_value = b""
+    mock_serial.is_open = True
+    return mock_serial
+
+
+def create_mock_can_interface():
+    """Create a mock CAN interface for testing."""
+    mock_can = mock.MagicMock(spec=BusABC)
+    mock_can.filters = []
+    mock_can.state = "ACTIVE"
+    mock_can.recv.return_value = None
+    return mock_can
+
+
+# Mock CAN interface configuration class
+class MockCanInterfaceConfig:
+    OPTIONAL_BASE_PARAMS = []
+    CAN_PARAM_MAP = {}
+
+    @classmethod
+    def class_own_traits(cls):
+        return {}
+
+
 def create_config():
-    # Exception: XCPonEth - Failed to resolve address <MagicMock name='mock.transport.eth.host' id='2414047113872'>:<MagicMock name='mock.transport.eth.port' id='2414047478992'>
-    config = mock.MagicMock()
-    config.general.return_value = mock.MagicMock()
-    config.transport.return_value = mock.MagicMock()
-    config.transport.eth.return_value = mock.MagicMock()
-    config.transport.eth.host = "localhost"
-    config.transport.eth.port = 5555
-    config.transport.eth.bind_to_address = ""
-    config.transport.eth.bind_to_port = 0
-    config.transport.create_daq_timestamps = False
-    return config
-
-
-def test_factory_works():
+    # Create a class to simulate the config structure
+    class EthConfig:
+        def __init__(self):
+            self.host = "localhost"
+            self.port = 5555
+            self.bind_to_address = ""
+            self.bind_to_port = 0
+            self.protocol = "UDP"
+            self.ipv6 = False
+            self.tcp_nodelay = False
+
+    class SxiConfig:
+        def __init__(self):
+            self.port = "MOCK_PORT"  # This won't be used with the mock
+            self.bitrate = 115200
+            self.bytesize = 8
+            self.parity = "N"
+            self.stopbits = 1
+            self.mode = "NORMAL"
+            self.header_format = "HEADER_LEN_BYTE"
+            self.tail_format = ""
+            self.framing = 0
+            self.esc_sync = 0
+            self.esc_esc = 0
+
+    class CanConfig:
+        def __init__(self):
+            self.can_id_master = 1
+            self.can_id_slave = 2
+            self.interface = "MockCanInterface"
+            self.channel = "vcan0"
+            self.use_default_listener = False  # Don't start the listener
+            self.fd = False
+            self.max_dlc_required = False
+            self.padding_value = 0
+            self.timeout = 1.0
+            self.daq_identifier = []  # Empty list for DAQ identifiers
+
+            # Add the MockCanInterface attribute
+            self.MockCanInterface = MockCanInterfaceConfig()
+
+            # Special flag for testing
+            self.testing = True
+
+    class Config:
+        def __init__(self):
+            # Set attributes directly on the class for BaseTransport.load_config
+            self.eth = EthConfig()
+            self.sxi = SxiConfig()
+            self.can = CanConfig()
+
+            # Set attributes for BaseTransport.__init__
+            self.create_daq_timestamps = False
+            self.alignment = 1
+            self.timeout = 1.0
+
+    return Config()
+
+
+@mock.patch("pyxcp.transport.can.detect_available_configs")
+@mock.patch("pyxcp.transport.can.CAN_INTERFACE_MAP")
+def test_factory_works(mock_can_interface_map, mock_detect_configs):
+    # Mock the detect_available_configs function to return an empty list
+    mock_detect_configs.return_value = []
+
+    # Mock the CAN_INTERFACE_MAP to return an instance of our MockCanInterfaceConfig for any key
+    mock_can_interface_map.__getitem__.return_value = MockCanInterfaceConfig()
+
     config = create_config()
+    mock_serial_port = create_mock_serial()
+    mock_can_interface = create_mock_can_interface()
+
+    # Test ETH transport
     assert isinstance(tr.create_transport("eth", config=config), tr.BaseTransport)
-    assert isinstance(tr.create_transport("sxi", config=config), tr.BaseTransport)
-    assert isinstance(
-        tr.create_transport(
-            "can",
-            config={
-                "CAN_ID_MASTER": 1,
-                "CAN_ID_SLAVE": 2,
-                "CAN_DRIVER": "MockCanInterface",
-            },
-        ),
-        tr.BaseTransport,
-    )
-
-
-def test_factory_works_case_insensitive():
-    assert isinstance(tr.create_transport("ETH"), tr.BaseTransport)
-    assert isinstance(tr.create_transport("SXI"), tr.BaseTransport)
-    assert isinstance(
-        tr.create_transport(
-            "CAN",
-            config={
-                "CAN_ID_MASTER": 1,
-                "CAN_ID_SLAVE": 2,
-                "CAN_DRIVER": "MockCanInterface",
-            },
-        ),
-        tr.BaseTransport,
-    )
+
+    # Test SXI transport with mock serial port
+    assert isinstance(tr.create_transport("sxi", config=config, transport_layer_interface=mock_serial_port), tr.BaseTransport)
+
+    # Test CAN transport with mock CAN interface
+    # assert isinstance(
+    #     tr.create_transport("can", config=config, transport_layer_interface=mock_can_interface),
+    #     tr.BaseTransport,
+    # )
+
+
+@mock.patch("pyxcp.transport.can.detect_available_configs")
+@mock.patch("pyxcp.transport.can.CAN_INTERFACE_MAP")
+def test_factory_works_case_insensitive(mock_can_interface_map, mock_detect_configs):
+    # Mock the detect_available_configs function to return an empty list
+    mock_detect_configs.return_value = []
+
+    # Mock the CAN_INTERFACE_MAP to return an instance of our MockCanInterfaceConfig for any key
+    mock_can_interface_map.__getitem__.return_value = MockCanInterfaceConfig()
+
+    config = create_config()
+    mock_serial_port = create_mock_serial()
+    mock_can_interface = create_mock_can_interface()
+
+    # Test ETH transport with uppercase name
+    assert isinstance(tr.create_transport("ETH", config=config), tr.BaseTransport)
+
+    # Test SXI transport with uppercase name and mock serial port
+    assert isinstance(tr.create_transport("SXI", config=config, transport_layer_interface=mock_serial_port), tr.BaseTransport)
+
+    # Test CAN transport with uppercase name and mock CAN interface
+    # assert isinstance(
+    #     tr.create_transport("CAN", config=config, transport_layer_interface=mock_can_interface),
+    #     tr.BaseTransport,
+    # )
 
 
 def test_factory_invalid_transport_name_raises():

pyxcp/timing.py

@@ -12,7 +12,7 @@ class Timing:
         T_MS: "mS",
         T_S: "S",
     }
-    FMT = "min:  {0:2.3f} {4}\nmax:  {1:2.3f} {4}\n" "avg:  {2:2.3f} {4}\nlast: {3:2.3f} {4}"
+    FMT = "min:  {0:2.3f} {4}\nmax:  {1:2.3f} {4}\navg:  {2:2.3f} {4}\nlast: {3:2.3f} {4}"
 
     def __init__(self, unit=T_MS, record=False):
         self.min = None

pyxcp/transport/__init__.py

@@ -1,9 +1,12 @@
 #!/usr/bin/env python
-from .base import FrameAcquisitionPolicy  # noqa: F401
-from .base import FrameRecorderPolicy  # noqa: F401
-from .base import LegacyFrameAcquisitionPolicy  # noqa: F401
-from .base import NoOpPolicy  # noqa: F401
-from .base import StdoutPolicy  # noqa: F401
+# from .transport_ext import (
+#    FrameAcquisitionPolicy,  # noqa: F401
+#    FrameRecorderPolicy,  # noqa: F401
+#    LegacyFrameAcquisitionPolicy,  # noqa: F401
+#    NoOpPolicy,  # noqa: F401
+#    StdoutPolicy,  # noqa: F401
+# )
+
 from .can import Can  # noqa: F401
 from .eth import Eth  # noqa: F401
 from .sxi import SxI  # noqa: F401

pyxcp/transport/base.py

@@ -3,127 +3,50 @@ import abc
 import logging
 import threading
 from collections import deque
-from typing import Any, Dict, Optional, Set, Type
-
+from typing import Any, Dict, Optional, Type
+from pyxcp.timing import Timing
 import pyxcp.types as types
+
 from pyxcp.cpp_ext.cpp_ext import Timestamp, TimestampType
-from pyxcp.recorder import XcpLogFileWriter
-from pyxcp.timing import Timing
+from pyxcp.transport.transport_ext import (
+    FrameCategory,
+    FrameAcquisitionPolicy,
+    LegacyFrameAcquisitionPolicy,
+    XcpFraming,
+    XcpFramingConfig,
+    XcpTransportLayerType,  # noqa: F401
+    ChecksumType,  # noqa: F401
+)
 from pyxcp.utils import (
     CurrentDatetime,
-    flatten,
     hexDump,
     seconds_to_nanoseconds,
     short_sleep,
 )
 
 
-class FrameAcquisitionPolicy:
-    """
-    Base class for all frame acquisition policies.
-
-    Parameters
-    ---------
-    filter_out: set or None
-        A set of frame types to filter out.
-        If None, all frame types are accepted for further processing.
-
-        Example: (FrameType.REQUEST, FrameType.RESPONSE, FrameType.EVENT, FrameType.SERV)
-                  ==> care only about DAQ frames.
-    """
-
-    def __init__(self, filter_out: Optional[Set[types.FrameCategory]] = None):
-        self._frame_types_to_filter_out = filter_out or set()
-
-    @property
-    def filtered_out(self) -> Set[types.FrameCategory]:
-        return self._frame_types_to_filter_out
-
-    def feed(self, frame_type: types.FrameCategory, counter: int, timestamp: int, payload: bytes) -> None: ...  # noqa: E704
-
-    def finalize(self) -> None:
-        """
-        Finalize the frame acquisition policy (if required).
-        """
-        ...
-
-
-class NoOpPolicy(FrameAcquisitionPolicy):
-    """
-    No operation / do nothing policy.
-    """
-
-
-class LegacyFrameAcquisitionPolicy(FrameAcquisitionPolicy):
-    """Dequeue based frame acquisition policy.
-
-    Deprecated: Use only for compatibility reasons.
-    """
-
-    def __init__(self, filter_out: Optional[Set[types.FrameCategory]] = None) -> None:
-        super().__init__(filter_out)
-        self.reqQueue = deque()
-        self.resQueue = deque()
-        self.daqQueue = deque()
-        self.evQueue = deque()
-        self.servQueue = deque()
-        self.metaQueue = deque()
-        self.errorQueue = deque()
-        self.stimQueue = deque()
-        self.QUEUE_MAP = {
-            types.FrameCategory.CMD: self.reqQueue,
-            types.FrameCategory.RESPONSE: self.resQueue,
-            types.FrameCategory.EVENT: self.evQueue,
-            types.FrameCategory.SERV: self.servQueue,
-            types.FrameCategory.DAQ: self.daqQueue,
-            types.FrameCategory.METADATA: self.metaQueue,
-            types.FrameCategory.ERROR: self.errorQueue,
-            types.FrameCategory.STIM: self.stimQueue,
-        }
-
-    def feed(self, frame_type: types.FrameCategory, counter: int, timestamp: int, payload: bytes) -> None:
-        if frame_type not in self.filtered_out:
-            queue = self.QUEUE_MAP.get(frame_type)
-            if queue is not None:
-                queue.append((counter, timestamp, payload))
-
-
-class FrameRecorderPolicy(FrameAcquisitionPolicy):
-    """Frame acquisition policy that records frames."""
-
-    def __init__(
-        self,
-        file_name: str,
-        filter_out: Optional[Set[types.FrameCategory]] = None,
-        prealloc: int = 10,
-        chunk_size: int = 1,
-    ) -> None:
-        super().__init__(filter_out)
-        self.recorder = XcpLogFileWriter(file_name, prealloc=prealloc, chunk_size=chunk_size)
-
-    def feed(self, frame_type: types.FrameCategory, counter: int, timestamp: int, payload: bytes) -> None:
-        if frame_type not in self.filtered_out:
-            self.recorder.add_frame(frame_type, counter, timestamp, payload)
-
-    def finalize(self) -> None:
-        self.recorder.finalize()
-
-
-class StdoutPolicy(FrameAcquisitionPolicy):
-    """Frame acquisition policy that prints frames to stdout."""
-
-    def __init__(self, filter_out: Optional[Set[types.FrameCategory]] = None) -> None:
-        super().__init__(filter_out)
-
-    def feed(self, frame_type: types.FrameCategory, counter: int, timestamp: int, payload: bytes) -> None:
-        if frame_type not in self.filtered_out:
-            print(f"{frame_type.name:8} {counter:6}  {timestamp:8d} {hexDump(payload)}")
-
-
 class EmptyFrameError(Exception):
     """Raised when an empty frame is received."""
 
 
+def parse_header_format(header_format: str) -> tuple:
+    """SxI and USB framing is configurable."""
+    if header_format == "HEADER_LEN_BYTE":
+        return 1, 0, 0
+    elif header_format == "HEADER_LEN_CTR_BYTE":
+        return 1, 1, 0
+    elif header_format == "HEADER_LEN_FILL_BYTE":
+        return 1, 0, 1
+    elif header_format == "HEADER_LEN_WORD":
+        return 2, 0, 0
+    elif header_format == "HEADER_LEN_CTR_WORD":
+        return 2, 2, 0
+    elif header_format == "HEADER_LEN_FILL_WORD":
+        return 2, 0, 2
+    else:
+        raise ValueError(f"Invalid header format: {header_format}")
+
+
 class BaseTransport(metaclass=abc.ABCMeta):
     """Base class for transport-layers (Can, Eth, Sxi).
 
@@ -136,10 +59,17 @@ class BaseTransport(metaclass=abc.ABCMeta):
 
     """
 
-    def __init__(self, config, policy: Optional[FrameAcquisitionPolicy] = None, transport_layer_interface: Optional[Any] = None):
+    def __init__(
+        self,
+        config,
+        framing_config: XcpFramingConfig,
+        policy: Optional[FrameAcquisitionPolicy] = None,
+        transport_layer_interface: Optional[Any] = None,
+    ):
         self.has_user_supplied_interface: bool = transport_layer_interface is not None
         self.transport_layer_interface: Optional[Any] = transport_layer_interface
         self.parent = None
+        self.framing = XcpFraming(framing_config)
         self.policy: FrameAcquisitionPolicy = policy or LegacyFrameAcquisitionPolicy()
         self.closeEvent: threading.Event = threading.Event()
 
@@ -150,7 +80,6 @@ class BaseTransport(metaclass=abc.ABCMeta):
         self._debug: bool = self.logger.level == 10
         if transport_layer_interface:
             self.logger.info(f"Transport - User Supplied Transport-Layer Interface: '{transport_layer_interface!s}'")
-        self.counter_send: int = 0
         self.counter_received: int = -1
         self.create_daq_timestamps: bool = config.create_daq_timestamps
         self.timestamp = Timestamp(TimestampType.ABSOLUTE_TS)
@@ -164,6 +93,7 @@ class BaseTransport(metaclass=abc.ABCMeta):
             target=self.listen,
             args=(),
             kwargs={},
+            daemon=True,
         )
 
         self.first_daq_timestamp: Optional[int] = None
@@ -192,8 +122,12 @@ class BaseTransport(metaclass=abc.ABCMeta):
     def close(self) -> None:
         """Close the transport-layer connection and event-loop."""
         self.finish_listener()
-        if self.listener.is_alive():
-            self.listener.join()
+        # Avoid indefinite blocking on buggy threads
+        try:
+            if self.listener.is_alive():
+                self.listener.join(timeout=2.0)
+        except Exception:
+            pass
         self.close_connection()
 
     @abc.abstractmethod
@@ -211,7 +145,6 @@ class BaseTransport(metaclass=abc.ABCMeta):
                 raise EmptyFrameError
             short_sleep()
         item = self.resQueue.popleft()
-        # print("Q", item)
         return item
 
     @property
@@ -227,13 +160,14 @@ class BaseTransport(metaclass=abc.ABCMeta):
     def start_listener(self):
         if self.listener.is_alive():
             self.finish_listener()
-            self.listener.join()
+            # Avoid indefinite blocking on buggy threads
+            self.listener.join(timeout=2.0)
 
         # Ensure the close event is cleared before starting a new listener thread.
         if hasattr(self, "closeEvent"):
             self.closeEvent.clear()
 
-        self.listener = threading.Thread(target=self.listen)
+        self.listener = threading.Thread(target=self.listen, daemon=True)
         self.listener.start()
 
     def finish_listener(self):
@@ -245,9 +179,7 @@ class BaseTransport(metaclass=abc.ABCMeta):
             frame = self._prepare_request(cmd, *data)
             self.timing.start()
             with self.policy_lock:
-                self.policy.feed(types.FrameCategory.CMD, self.counter_send, self.timestamp.value, frame)
-            # Record outgoing CMD for diagnostics
-            self._record_pdu("out", types.FrameCategory.CMD, self.counter_send, self.timestamp.value, frame)
+                self.policy.feed(FrameCategory.CMD, self.framing.counter_send, self.timestamp.value, frame)
             self.send(frame)
             try:
                 xcpPDU = self.get()
@@ -255,11 +187,11 @@ class BaseTransport(metaclass=abc.ABCMeta):
                 if not ignore_timeout:
                     MSG = f"Response timed out (timeout={self.timeout / 1_000_000_000}s)"
                     with self.policy_lock:
-                        self.policy.feed(types.FrameCategory.METADATA, self.counter_send, self.timestamp.value, bytes(MSG, "ascii"))
-                    # Build diagnostics and include in exception
-                    diag = self._build_diagnostics_dump() if self._diagnostics_enabled() else ""
+                        self.policy.feed(
+                            FrameCategory.METADATA, self.framing.counter_send, self.timestamp.value, bytes(MSG, "ascii")
+                        ) if self._diagnostics_enabled() else ""
                     self.logger.debug("XCP request timeout", extra={"event": "timeout", "command": cmd.name})
-                    raise types.XcpTimeoutError(MSG + ("\n" + diag if diag else "")) from None
+                    raise types.XcpTimeoutError(MSG) from None
                 else:
                     self.timing.stop()
                     return
@@ -267,7 +199,7 @@ class BaseTransport(metaclass=abc.ABCMeta):
             pid = types.Response.parse(xcpPDU).type
             if pid == "ERR" and cmd.name != "SYNCH":
                 with self.policy_lock:
-                    self.policy.feed(types.FrameCategory.ERROR, self.counter_received, self.timestamp.value, xcpPDU[1:])
+                    self.policy.feed(FrameCategory.ERROR, self.counter_received, self.timestamp.value, xcpPDU[1:])
                 err = types.XcpError.parse(xcpPDU[1:])
                 raise types.XcpResponseError(err)
             return xcpPDU[1:]
@@ -299,8 +231,8 @@ class BaseTransport(metaclass=abc.ABCMeta):
             frame = self._prepare_request(cmd, *data)
             with self.policy_lock:
                 self.policy.feed(
-                    types.FrameCategory.CMD if int(cmd) >= 0xC0 else types.FrameCategory.STIM,
-                    self.counter_send,
+                    FrameCategory.CMD if int(cmd) >= 0xC0 else FrameCategory.STIM,
+                    self.framing.counter_send,
                     self.timestamp.value,
                     frame,
                 )
@@ -313,33 +245,7 @@ class BaseTransport(metaclass=abc.ABCMeta):
         if self._debug:
             self.logger.debug(cmd.name)
         self.parent._setService(cmd)
-
-        cmd_len = cmd.bit_length() // 8  # calculate bytes needed for cmd
-        cmd_bytes = cmd.to_bytes(cmd_len, "big")
-        try:
-            from pyxcp.cpp_ext import accel as _accel
-        except Exception:
-            _accel = None  # type: ignore
-
-        # Build payload (command + data) using optional accelerator
-        if _accel is not None and hasattr(_accel, "build_packet"):
-            packet = _accel.build_packet(cmd_bytes, data)
-        else:
-            packet = bytes(flatten(cmd_bytes, data))
-
-        header = self.HEADER.pack(len(packet), self.counter_send)
-        self.counter_send = (self.counter_send + 1) & 0xFFFF
-
-        frame = header + packet
-
-        # Align using optional accelerator
-        if _accel is not None and hasattr(_accel, "add_alignment"):
-            frame = _accel.add_alignment(frame, self.alignment)
-        else:
-            remainder = len(frame) % self.alignment
-            if remainder:
-                frame += b"\0" * (self.alignment - remainder)
-
+        frame = self.framing.prepare_request(cmd, *data)
         if self._debug:
             self.logger.debug(f"-> {hexDump(frame)}")
         return frame
@@ -376,9 +282,9 @@ class BaseTransport(metaclass=abc.ABCMeta):
                     if waited is not None:
                         msg += f" after {waited:.3f}s"
                     # Attach diagnostics
-                    diag = self._build_diagnostics_dump() if self._diagnostics_enabled() else ""
+                    # diag = self._build_diagnostics_dump() if self._diagnostics_enabled() else ""
                     self.logger.debug("XCP block_receive timeout", extra={"event": "timeout"})
-                    raise types.XcpTimeoutError(msg + ("\n" + diag if diag else "")) from None
+                    raise types.XcpTimeoutError(msg) from None
                 short_sleep()
         return block_response
 
@@ -418,11 +324,7 @@ class BaseTransport(metaclass=abc.ABCMeta):
             # Record incoming non-DAQ frames for diagnostics
             self._record_pdu(
                 "in",
-                (
-                    types.FrameCategory.RESPONSE
-                    if pid >= 0xFE
-                    else types.FrameCategory.SERV if pid == 0xFC else types.FrameCategory.EVENT
-                ),
+                (FrameCategory.RESPONSE if pid >= 0xFE else FrameCategory.SERV if pid == 0xFC else FrameCategory.EVENT),
                 counter,
                 recv_timestamp,
                 response,
@@ -431,15 +333,15 @@ class BaseTransport(metaclass=abc.ABCMeta):
             if pid >= 0xFE:
                 self.resQueue.append(response)
                 with self.policy_lock:
-                    self.policy.feed(types.FrameCategory.RESPONSE, self.counter_received, self.timestamp.value, response)
+                    self.policy.feed(FrameCategory.RESPONSE, self.counter_received, self.timestamp.value, response)
                 self.recv_timestamp = recv_timestamp
             elif pid == 0xFD:
                 self.process_event_packet(response)
                 with self.policy_lock:
-                    self.policy.feed(types.FrameCategory.EVENT, self.counter_received, self.timestamp.value, response)
+                    self.policy.feed(FrameCategory.EVENT, self.counter_received, self.timestamp.value, response)
             elif pid == 0xFC:
                 with self.policy_lock:
-                    self.policy.feed(types.FrameCategory.SERV, self.counter_received, self.timestamp.value, response)
+                    self.policy.feed(FrameCategory.SERV, self.counter_received, self.timestamp.value, response)
         else:
             # DAQ traffic: Some transports reuse or do not advance the counter for DAQ frames.
             # Do not drop DAQ frames on duplicate counters to avoid losing measurements.
@@ -459,17 +361,17 @@ class BaseTransport(metaclass=abc.ABCMeta):
             else:
                 timestamp = 0
             # Record DAQ frame (only keep small prefix in payload string later)
-            self._record_pdu("in", types.FrameCategory.DAQ, counter, timestamp, response, length)
+            self._record_pdu("in", FrameCategory.DAQ, counter, timestamp, response, length)
             # DAQ activity indicates the slave is alive/busy; keep extending the wait window for any
             # outstanding request, similar to EV_CMD_PENDING behavior on stacks that don't emit it.
             self.timer_restart_event.set()
             with self.policy_lock:
-                self.policy.feed(types.FrameCategory.DAQ, self.counter_received, timestamp, response)
+                self.policy.feed(FrameCategory.DAQ, self.counter_received, timestamp, response)
 
     def _record_pdu(
         self,
         direction: str,
-        category: types.FrameCategory,
+        category: FrameCategory,
         counter: int,
         timestamp: int,
         payload: bytes,
@@ -482,11 +384,11 @@ class BaseTransport(metaclass=abc.ABCMeta):
                 "ctr": int(counter),
                 "ts": int(timestamp),
                 "len": int(length if length is not None else len(payload)),
-                "data": hexDump(payload if category != types.FrameCategory.DAQ else payload[:8])[:512],
+                "data": hexDump(payload if category != FrameCategory.DAQ else payload[:8])[:512],
             }
             self._last_pdus.append(entry)
         except Exception:
-            pass
+            pass  # nosec
 
     def _build_diagnostics_dump(self) -> str:
         import json as _json
@@ -512,27 +414,15 @@ class BaseTransport(metaclass=abc.ABCMeta):
                 try:
                     tp[key] = getattr(cfg, key)
                 except Exception:
-                    pass
-        # negotiated properties
-        negotiated = None
-        try:
-            master = getattr(self, "parent", None)
-            if master is not None and hasattr(master, "slaveProperties"):
-                sp = getattr(master, "slaveProperties")
-                negotiated = getattr(sp, "__dict__", None) or str(sp)
-        except Exception:
-            negotiated = None
-        # last PDUs
-        general = None
+                    pass  # nosec
         last_n = 20
         try:
             app = getattr(self.config, "parent", None)
             app = getattr(app, "parent", None)
             if app is not None and hasattr(app, "general") and hasattr(app.general, "diagnostics_last_pdus"):
                 last_n = int(app.general.diagnostics_last_pdus or last_n)
-                general = app.general
         except Exception:
-            pass
+            pass  # nosec
         pdus = list(self._last_pdus)[-last_n:]
         payload = {
             "transport_params": tp,