pyxcp 0.23.3__cp311-cp311-win_arm64.whl → 0.23.6__cp311-cp311-win_arm64.whl

pyxcp/recorder/unfolder.hpp

@@ -1139,6 +1139,50 @@ class DaqRecorderPolicy : public DAQPolicyBase {
     bool                              m_initialized{ false };
 };
 
+class DaqTimeTracker {
+public:
+
+    DaqTimeTracker(std::uint64_t overflow_value) : m_overflow_value(overflow_value), m_overflow_counter(0ULL), m_previous_timestamp(0ULL) { m_ts_base_set=false; m_ts0_base=0ULL; m_ts1_base=0ULL; }
+
+    auto get_previous_timestamp() const noexcept {
+        return m_previous_timestamp;
+    }
+
+    void set_previous_timestamp(std::uint64_t timestamp) noexcept {
+        m_previous_timestamp = timestamp;
+    }
+
+    void inc_overflow_counter() noexcept {
+        m_overflow_counter++;
+    }
+
+    auto get_overflow_counter() const noexcept {
+        return m_overflow_counter;
+    }
+
+    auto get_value() const noexcept {
+        return m_overflow_value * m_overflow_counter;
+    }
+
+public:
+    std::pair<std::uint64_t,std::uint64_t> normalize(std::uint64_t ts0, std::uint64_t ts1) noexcept {
+        if (!m_ts_base_set) {
+            m_ts0_base = ts0;
+            m_ts1_base = ts1;
+            m_ts_base_set = true;
+        }
+        return {ts0 - m_ts0_base, ts1 - m_ts1_base};
+    }
+private:
+    std::uint64_t m_overflow_value{};
+    std::uint64_t m_overflow_counter{};
+    std::uint64_t m_previous_timestamp{};
+    bool m_ts_base_set{false};
+    std::uint64_t m_ts0_base{0ULL};
+    std::uint64_t m_ts1_base{0ULL};
+};
+
+
 class DaqOnlinePolicy : public DAQPolicyBase {
    public:
 
@@ -1149,6 +1193,9 @@ class DaqOnlinePolicy : public DAQPolicyBase {
 
     void set_parameters(const MeasurementParameters& params) noexcept {
         m_decoder = std::make_unique<DAQProcessor>(params);
+		for (auto idx=0; idx < params.get_daq_lists().size(); ++idx) {
+            m_overflows.emplace_back(DaqTimeTracker(params.get_overflow_value()));
+        }
         DAQPolicyBase::set_parameters(params);
     }
 
@@ -1164,71 +1211,34 @@ class DaqOnlinePolicy : public DAQPolicyBase {
         auto result = m_decoder->feed(timestamp, payload);
         if (result) {
             const auto& [daq_list, ts0, ts1, meas] = *result;
-            on_daq_list(daq_list, ts0, ts1, meas);
-        }
-    }
 
-    virtual void initialize() {
-    }
+			auto& overflow = m_overflows[daq_list];
 
-    virtual void finalize() {
-    }
+            auto [norm_ts0, norm_ts1] = overflow.normalize(ts0, ts1);
 
-   private:
+			if (overflow.get_previous_timestamp() > norm_ts1) {
+				overflow.inc_overflow_counter();
+            }
 
-    std::unique_ptr<DAQProcessor> m_decoder;
-};
+			on_daq_list(daq_list, norm_ts0, norm_ts1 + overflow.get_value(), meas);
 
-struct ValueHolder {
-    ValueHolder()                   = delete;
-    ValueHolder(const ValueHolder&) = default;
+			overflow.set_previous_timestamp(norm_ts1);
 
-    ValueHolder(const std::any& value) : m_value(value) {
+        }
     }
 
-    ValueHolder(std::any&& value) : m_value(std::move(value)) {
+    virtual void initialize() {
     }
 
-    std::any get_value() const noexcept {
-        return m_value;
+    virtual void finalize() {
     }
 
    private:
 
-    std::any m_value;
+    std::unique_ptr<DAQProcessor> m_decoder;
+	std::vector<DaqTimeTracker>   m_overflows;
 };
 
-class Overflow {
-public:
-
-    Overflow(std::uint64_t overflow_value) : m_overflow_value(overflow_value), m_overflow_counter(0ULL), m_previous_timestamp(0ULL) {
-    }
-
-    auto get_previous_timestamp() const noexcept {
-        return m_previous_timestamp;
-    }
-
-    void set_previous_timestamp(std::uint64_t timestamp) noexcept {
-        m_previous_timestamp = timestamp;
-    }
-
-    void inc_overflow_counter() noexcept {
-        m_overflow_counter++;
-    }
-
-    auto get_overflow_counter() const noexcept {
-        return m_overflow_counter;
-    }
-
-    auto get_value() const noexcept {
-        return m_overflow_value * m_overflow_counter;
-    }
-
-private:
-    std::uint64_t m_overflow_value{};
-    std::uint64_t m_overflow_counter{};
-    std::uint64_t m_previous_timestamp{};
-};
 
 class XcpLogFileDecoder {
    public:
@@ -1240,12 +1250,12 @@ class XcpLogFileDecoder {
             m_params  = des.run();
 
             for (auto idx=0; idx < m_params.get_daq_lists().size(); ++idx) {
-                m_overflows.emplace_back(Overflow(m_params.get_overflow_value()));
+                m_overflows.emplace_back(DaqTimeTracker(m_params.get_overflow_value()));
             }
 
             m_decoder = std::make_unique<DAQProcessor>(m_params);
         } else {
-            // cannot proceed!!!
+            throw std::runtime_error("XcpLogFileDecoder: missing metadata.");
         }
     }
 
@@ -1289,15 +1299,17 @@ class XcpLogFileDecoder {
 
                     auto& overflow = m_overflows[daq_list];
 
-                    if (overflow.get_previous_timestamp() > ts1) {
+                    auto [norm_ts0, norm_ts1] = overflow.normalize(ts0, ts1);
+
+                    if (overflow.get_previous_timestamp() > norm_ts1) {
                         overflow.inc_overflow_counter();
                         // Maybe on debug-level?
                         // std::cout << "Overflow detected, counter: " << overflow.get_overflow_counter() << " " << overflow.get_previous_timestamp() << " " << ts1 << std::endl;
                     }
 
-                    on_daq_list(daq_list, ts0, ts1 + overflow.get_value(), meas);
+                    on_daq_list(daq_list, norm_ts0, norm_ts1 + overflow.get_value(), meas);
 
-                    overflow.set_previous_timestamp(ts1);
+                    overflow.set_previous_timestamp(norm_ts1);
                 }
             }
         }
@@ -1326,7 +1338,7 @@ class XcpLogFileDecoder {
     XcpLogFileReader              m_reader;
     std::unique_ptr<DAQProcessor> m_decoder;
     MeasurementParameters         m_params;
-    std::vector<Overflow>           m_overflows;
+    std::vector<DaqTimeTracker>   m_overflows;
 };
 
 #endif  // RECORDER_UNFOLDER_HPP

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()
@@ -222,6 +229,10 @@ class BaseTransport(metaclass=abc.ABCMeta):
             self.finish_listener()
             self.listener.join()
 
+        # 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.start()
 
@@ -235,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()
@@ -243,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
@@ -299,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)}")
@@ -341,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
 
@@ -368,16 +405,29 @@ class BaseTransport(metaclass=abc.ABCMeta):
             self.timer_restart_event.set()
 
     def process_response(self, response: bytes, length: int, counter: int, recv_timestamp: int) -> None:
-        if counter == self.counter_received:
-            self.logger.warning(f"Duplicate message counter {counter} received from the XCP slave")
-            if self._debug:
-                self.logger.debug(f"<- L{length} C{counter} {hexDump(response[:512])}")
-            return
-        self.counter_received = counter
+        # Important: determine PID first so duplicate counter handling can be applied selectively.
         pid = response[0]
+
         if pid >= 0xFC:
+            # Do not drop RESPONSE/EVENT/SERV frames even if the transport counter repeats.
+            # Some slaves may reuse the counter while DAQ traffic is active, and we must not lose
+            # command responses; otherwise request() can stall until timeout.
             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:
@@ -391,6 +441,15 @@ class BaseTransport(metaclass=abc.ABCMeta):
                 with self.policy_lock:
                     self.policy.feed(types.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.
+            if counter == self.counter_received:
+                self.logger.debug(f"Duplicate message counter {counter} received (DAQ) - not dropping")
+                # DAQ still flowing – reset request timeout window to avoid false timeouts while
+                # the slave is busy but has not yet responded to a command.
+                self.timer_restart_event.set()
+                # Fall through and process the frame as usual.
+            self.counter_received = counter
             if self._debug:
                 self.logger.debug(f"<- L{length} C{counter} ODT_Data[0:8] {hexDump(response[:8])}")
             if self.first_daq_timestamp is None:
@@ -399,9 +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