pyxcp 0.23.4__cp312-cp312-macosx_11_0_arm64.whl → 0.23.7__cp312-cp312-macosx_11_0_arm64.whl

pyxcp/recorder/wrap.cpp

@@ -11,7 +11,6 @@
 namespace py = pybind11;
 using namespace pybind11::literals;
 
-PYBIND11_MAKE_OPAQUE(ValueHolder);
 
 class PyDaqOnlinePolicy : public DaqOnlinePolicy {
    public:
@@ -181,9 +180,4 @@ PYBIND11_MODULE(rekorder, m) {
         .def("get_header", &XcpLogFileDecoder::get_header)
         .def("initialize", &XcpLogFileDecoder::initialize)
         .def("finalize", &XcpLogFileDecoder::finalize);
-
-    py::class_<ValueHolder>(m, "ValueHolder")
-        //.def(py::init<const ValueHolder&>())
-        .def(py::init<const std::any&>())
-        .def_property_readonly("value", &ValueHolder::get_value);
 }

pyxcp/transport/base.py

@@ -172,6 +172,13 @@ class BaseTransport(metaclass=abc.ABCMeta):
         self.pre_send_timestamp: int = self.timestamp.value
         self.post_send_timestamp: int = self.timestamp.value
         self.recv_timestamp: int = self.timestamp.value
+        # Ring buffer for last PDUs to aid diagnostics on failures
+        try:
+            from collections import deque as _dq
+
+            self._last_pdus = _dq(maxlen=200)
+        except Exception:
+            self._last_pdus = []
 
     def __del__(self) -> None:
         self.finish_listener()
@@ -239,6 +246,8 @@ class BaseTransport(metaclass=abc.ABCMeta):
             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.send(frame)
             try:
                 xcpPDU = self.get()
@@ -247,7 +256,10 @@ class BaseTransport(metaclass=abc.ABCMeta):
                     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"))
-                    raise types.XcpTimeoutError(MSG) from None
+                    # Build diagnostics and include in exception
+                    diag = self._build_diagnostics_dump() 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
                 else:
                     self.timing.stop()
                     return
@@ -303,16 +315,30 @@ class BaseTransport(metaclass=abc.ABCMeta):
         self.parent._setService(cmd)
 
         cmd_len = cmd.bit_length() // 8  # calculate bytes needed for cmd
-        packet = bytes(flatten(cmd.to_bytes(cmd_len, "big"), data))
+        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
 
-        remainder = len(frame) % self.alignment
-        if remainder:
-            frame += b"\0" * (self.alignment - remainder)
+        # 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)
 
         if self._debug:
             self.logger.debug(f"-> {hexDump(frame)}")
@@ -345,7 +371,14 @@ class BaseTransport(metaclass=abc.ABCMeta):
                 block_response += partial_response[1:]
             else:
                 if self.timestamp.value - start > self.timeout:
-                    raise types.XcpTimeoutError("Response timed out [block_receive].") from None
+                    waited = (self.timestamp.value - start) / 1e9 if hasattr(self.timestamp, "value") else None
+                    msg = f"Response timed out [block_receive]: received {len(block_response)} of {length_required} bytes"
+                    if waited is not None:
+                        msg += f" after {waited:.3f}s"
+                    # Attach diagnostics
+                    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
                 short_sleep()
         return block_response
 
@@ -382,6 +415,19 @@ class BaseTransport(metaclass=abc.ABCMeta):
             if self._debug:
                 self.logger.debug(f"<- L{length} C{counter} {hexDump(response)}")
             self.counter_received = counter
+            # 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
+                ),
+                counter,
+                recv_timestamp,
+                response,
+                length,
+            )
             if pid >= 0xFE:
                 self.resQueue.append(response)
                 with self.policy_lock:
@@ -412,12 +458,104 @@ class BaseTransport(metaclass=abc.ABCMeta):
                 timestamp = recv_timestamp
             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)
             # 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)
 
+    def _record_pdu(
+        self,
+        direction: str,
+        category: types.FrameCategory,
+        counter: int,
+        timestamp: int,
+        payload: bytes,
+        length: Optional[int] = None,
+    ) -> None:
+        try:
+            entry = {
+                "dir": direction,
+                "cat": category.name,
+                "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],
+            }
+            self._last_pdus.append(entry)
+        except Exception:
+            pass
+
+    def _build_diagnostics_dump(self) -> str:
+        import json as _json
+
+        # transport params
+        tp = {"transport": self.__class__.__name__}
+        cfg = getattr(self, "config", None)
+        # Extract common Eth/Can fields when available
+        for key in (
+            "host",
+            "port",
+            "protocol",
+            "ipv6",
+            "bind_to_address",
+            "bind_to_port",
+            "fd",
+            "bitrate",
+            "data_bitrate",
+            "can_id_master",
+            "can_id_slave",
+        ):
+            if cfg is not None and hasattr(cfg, key):
+                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
+        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
+        pdus = list(self._last_pdus)[-last_n:]
+        payload = {
+            "transport_params": tp,
+            "last_pdus": pdus,
+        }
+        try:
+            body = _json.dumps(payload, ensure_ascii=False, default=str, indent=2)
+        except Exception:
+            body = str(payload)
+        # Add a small header to explain what follows
+        header = "--- Diagnostics (for troubleshooting) ---"
+        return f"{header}\n{body}"
+
+    def _diagnostics_enabled(self) -> bool:
+        try:
+            app = getattr(self.config, "parent", None)
+            app = getattr(app, "parent", None)
+            if app is not None and hasattr(app, "general"):
+                return bool(getattr(app.general, "diagnostics_on_failure", True))
+        except Exception:
+            return True
+        return True
+
     # @abc.abstractproperty
     # @property
     # def transport_layer_interface(self) -> Any:

pyxcp/transport/can.py

@@ -292,7 +292,13 @@ class PythonCanWrapper:
         self.timeout: int = timeout
         self.parameters = parameters
         if not self.parent.has_user_supplied_interface:
-            self.can_interface_class = _get_class_for_interface(self.interface_name)
+            try:
+                self.can_interface_class = _get_class_for_interface(self.interface_name)
+            except Exception as ex:
+                # Provide clearer message if interface not supported by python-can on this platform
+                raise CanInitializationError(
+                    f"Unsupported or unavailable CAN interface {self.interface_name!r}: {ex.__class__.__name__}: {ex}"
+                ) from ex
         else:
             self.can_interface_class = None
         self.can_interface: BusABC
@@ -320,7 +326,15 @@ class PythonCanWrapper:
             self.can_interface.set_filters(merged_filters)
             self.software_filter.set_filters(can_filters)  # Filter unwanted traffic.
         else:
-            self.can_interface = self.can_interface_class(interface=self.interface_name, can_filters=can_filters, **self.parameters)
+            try:
+                self.can_interface = self.can_interface_class(
+                    interface=self.interface_name, can_filters=can_filters, **self.parameters
+                )
+            except OSError as ex:
+                # Typical when selecting socketcan on unsupported OS (e.g., Windows)
+                raise CanInitializationError(
+                    f"OS error while creating CAN interface {self.interface_name!r}: {ex.__class__.__name__}: {ex}"
+                ) from ex
             self.software_filter.accept_all()
         self.parent.logger.info(f"XCPonCAN - Using Interface: '{self.can_interface!s}'")
         self.parent.logger.info(f"XCPonCAN - Filters used: {self.can_interface.filters}")
@@ -401,13 +415,33 @@ class Can(BaseTransport):
         self.padding_value = self.config.padding_value
         if transport_layer_interface is None:
             self.interface_name = self.config.interface
-            self.interface_configuration = detect_available_configs(interfaces=[self.interface_name])
+            # On platforms that do not support certain backends (e.g., SocketCAN on Windows),
+            # python-can may raise OSError deep inside interface initialization. We want to
+            # fail fast with a clearer hint and avoid unhandled low-level errors.
+            try:
+                self.interface_configuration = detect_available_configs(interfaces=[self.interface_name])
+            except Exception as ex:
+                # Best-effort graceful message; keep original exception context
+                self.logger.critical(
+                    f"XCPonCAN - Failed to query available configs for interface {self.interface_name!r}: {ex.__class__.__name__}: {ex}"
+                )
+                self.interface_configuration = []
             parameters = self.get_interface_parameters()
         else:
             self.interface_name = "custom"
             # print("TRY GET PARAMs", self.get_interface_parameters())
             parameters = {}
-        self.can_interface = PythonCanWrapper(self, self.interface_name, config.timeout, **parameters)
+        try:
+            self.can_interface = PythonCanWrapper(self, self.interface_name, config.timeout, **parameters)
+        except OSError as ex:
+            # Catch platform-specific socket errors early (e.g., SocketCAN on Windows)
+            msg = (
+                f"XCPonCAN - Failed to initialize CAN interface {self.interface_name!r}: "
+                f"{ex.__class__.__name__}: {ex}.\n"
+                f"Hint: Interface may be unsupported on this OS or missing drivers."
+            )
+            self.logger.critical(msg)
+            raise CanInitializationError(msg) from ex
         self.logger.info(f"XCPonCAN - Interface-Type: {self.interface_name!r} Parameters: {list(parameters.items())}")
         self.logger.info(
             f"XCPonCAN - Master-ID (Tx): 0x{self.can_id_master.id:08X}{self.can_id_master.type_str} -- "
@@ -459,15 +493,34 @@ class Can(BaseTransport):
                 self.data_received(frame.data, frame.timestamp)
 
     def connect(self):
-        if self.useDefaultListener:
-            self.start_listener()
+        # Start listener lazily after a successful interface connection to avoid a dangling
+        # thread waiting on a not-yet-connected interface if initialization fails.
         try:
             self.can_interface.connect()
         except CanInitializationError:
+            # Ensure any previously-started listener is stopped to prevent hangs.
+            self.finish_listener()
             console.print("[red]\nThere may be a problem with the configuration of your CAN-interface.\n")
             console.print(f"[grey]Current configuration of interface {self.interface_name!r}:")
             console.print(self.interface_configuration)
             raise
+        except OSError as ex:
+            # Ensure any previously-started listener is stopped to prevent hangs.
+            self.finish_listener()
+            # E.g., attempting to instantiate SocketCAN on Windows raises an OSError from socket layer.
+            # Provide a clearer, actionable message and keep the original exception.
+            msg = (
+                f"XCPonCAN - OS error while initializing interface {self.interface_name!r}: "
+                f"{ex.__class__.__name__}: {ex}.\n"
+                f"Hint: This interface may not be supported on your platform. "
+                f"On Windows, use e.g. 'vector', 'kvaser', 'pcan', or other vendor backends instead of 'socketcan'."
+            )
+            self.logger.critical(msg)
+            raise CanInitializationError(msg) from ex
+        else:
+            # Only now start the default listener if requested.
+            if self.useDefaultListener:
+                self.start_listener()
         self.status = 1  # connected
 
     def send(self, frame: bytes) -> None:

pyxcp/transport/eth.py

@@ -69,8 +69,8 @@ class Eth(BaseTransport):
                 self.sockaddr,
             ) = addrinfo[0]
         except BaseException as ex:  # noqa: B036
-            msg = f"XCPonEth - Failed to resolve address {self.host}:{self.port}"
-            self.logger.critical(msg)
+            msg = f"XCPonEth - Failed to resolve address {self.host}:{self.port} ({self.protocol}, ipv6={self.ipv6}): {ex.__class__.__name__}: {ex}"
+            self.logger.critical(msg, extra={"transport": "eth", "host": self.host, "port": self.port, "protocol": self.protocol})
             raise Exception(msg) from ex
         self.status: int = 0
         self.sock = socket.socket(self.address_family, self.socktype, self.proto)
@@ -87,8 +87,10 @@ class Eth(BaseTransport):
             try:
                 self.sock.bind(self._local_address)
             except BaseException as ex:  # noqa: B036
-                msg = f"XCPonEth - Failed to bind socket to given address {self._local_address}"
-                self.logger.critical(msg)
+                msg = f"XCPonEth - Failed to bind socket to given address {self._local_address}: {ex.__class__.__name__}: {ex}"
+                self.logger.critical(
+                    msg, extra={"transport": "eth", "host": self.host, "port": self.port, "protocol": self.protocol}
+                )
                 raise Exception(msg) from ex
         self._packet_listener = threading.Thread(
             target=self._packet_listen,
@@ -194,7 +196,23 @@ class Eth(BaseTransport):
                     else:
                         if current_size >= length:
                             response = data[current_position : current_position + length]
-                            process_response(response, length, counter, timestamp)
+                            try:
+                                process_response(response, length, counter, timestamp)
+                            except BaseException as ex:  # Guard listener against unhandled exceptions (e.g., disk full in policy)
+                                try:
+                                    self.logger.critical(
+                                        f"Listener error in process_response: {ex.__class__.__name__}: {ex}. Stopping listener.",
+                                        extra={"event": "listener_error"},
+                                    )
+                                except Exception:
+                                    pass
+                                try:
+                                    # Signal all loops to stop
+                                    if hasattr(self, "closeEvent"):
+                                        self.closeEvent.set()
+                                except Exception:
+                                    pass
+                                return
                             current_size -= length
                             current_position += length
                             length = None

pyxcp/utils.py

@@ -113,8 +113,8 @@ def enum_from_str(enum_class: IntEnum, enumerator: str) -> IntEnum:
 
     enumerator: str
 
-    Example
-    -------
+    Examples
+    --------
 
     class Color(enum.IntEnum):
         RED = 0