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

pyxcp/cpp_ext/sxi_framing.hpp

@@ -0,0 +1,332 @@
+#if !defined (__SXI_FRAMING_HPP)
+#define __SXI_FRAMING_HPP
+
+#include <array>
+#include <bit>
+#include <chrono>
+#include <condition_variable>
+#include <cstdint>
+#include <functional>
+#include <memory>
+#include <mutex>
+#include <thread>
+#include <vector>
+#include <iomanip>
+#include <iostream>
+
+// Header format options
+enum class SxiHeaderFormat {
+    LenByte,
+    LenCtrByte,
+    LenFillByte,
+    LenWord,
+    LenCtrWord,
+    LenFillWord,
+};
+
+// Checksum type options
+enum class SxiChecksumType {
+    None,
+    Sum8,
+    Sum16
+};
+
+namespace detail {
+inline uint16_t make_word_le(const uint8_t* p) {
+    return p[0] | p[1] << 8;
+}
+
+inline void put_word_le(uint8_t* p, uint16_t v) {
+    if constexpr (std::endian::native == std::endian::big) {
+        p[0] = static_cast<uint8_t>(v & 0xFF);
+        p[1] = static_cast<uint8_t>((v >> 8) & 0xFF);
+    } else {
+        std::memcpy(p, &v, sizeof(v));
+    }
+}
+}  // namespace detail
+
+class RestartableTimer {
+   public:
+
+    /**
+     * @brief Constructs the timer.
+     * @param timeout The duration after which the timer expires.
+     * @param on_timeout The function to call upon timeout.
+     */
+    RestartableTimer(std::chrono::milliseconds timeout, std::function<void()> on_timeout) :
+        m_timeout(timeout), m_on_timeout(std::move(on_timeout)), m_running(false) {
+    }
+
+    ~RestartableTimer() {
+        stop();
+        if (m_thread.joinable()) {
+            m_thread.join();
+        }
+    }
+
+    // Disable copy and move semantics
+    RestartableTimer(const RestartableTimer&)            = delete;
+    RestartableTimer& operator=(const RestartableTimer&) = delete;
+    RestartableTimer(RestartableTimer&&)                 = delete;
+    RestartableTimer& operator=(RestartableTimer&&)      = delete;
+
+    /**
+     * @brief Starts the timer. If already running, it resets the countdown.
+     */
+    void start() {
+        if (m_timeout == std::chrono::milliseconds(0)) {
+            return;
+        }
+        std::unique_lock<std::mutex> lock(m_mutex);
+        if (!m_running) {
+            m_running = true;
+            if (m_thread.joinable()) {
+                m_thread.join();  // Ensure previous thread is finished
+            }
+            m_thread = std::thread(&RestartableTimer::run, this);
+        } else {
+            // Already running, just signal a reset
+            m_cv.notify_one();
+        }
+    }
+
+    /**
+     * @brief Stops the timer.
+     */
+    void stop() {
+        if (m_timeout == std::chrono::milliseconds(0)) {
+            return;
+        }
+        std::unique_lock<std::mutex> lock(m_mutex);
+        if (!m_running) {
+            return;
+        }
+        m_running = false;
+        m_cv.notify_one();
+    }
+
+    /**
+     * @brief Resets the timer's countdown.
+     */
+    void reset_timeout() {
+        if (m_timeout == std::chrono::milliseconds(0)) {
+            return;
+        }
+        std::unique_lock<std::mutex> lock(m_mutex);
+        if (m_running) {
+            m_cv.notify_one();
+        }
+    }
+
+   private:
+
+    void run() {
+        std::unique_lock<std::mutex> lock(m_mutex);
+        while (m_running) {
+            // wait_for returns cv_status::timeout if the time expires without a notification
+            if (m_cv.wait_for(lock, m_timeout) == std::cv_status::timeout) {
+                // Timeout occurred. Check m_running again in case stop() was called
+                // while we were waiting for the lock.
+                if (m_running) {
+                    m_on_timeout();
+                    m_running = false;  // Stop the timer thread after firing
+                }
+            }
+        }
+    }
+
+    std::thread               m_thread;
+    std::mutex                m_mutex;
+    std::condition_variable   m_cv;
+    std::chrono::milliseconds m_timeout;
+    std::function<void()>     m_on_timeout;
+    std::atomic<bool>         m_running;
+};
+
+
+template<SxiHeaderFormat Format, SxiChecksumType Checksum>
+class SxiReceiver {
+   public:
+
+    explicit SxiReceiver(
+        std::function<void(const std::vector<uint8_t>&, uint16_t, uint16_t)> dispatch_handler,
+        std::chrono::milliseconds /*timeout*/ = std::chrono::milliseconds(0)
+    ) :
+        dispatch_(std::move(dispatch_handler)) {
+        reset();
+    }
+
+    void feed_bytes(const std::string& data) {
+        for (const auto& c : data) {
+            //feed(static_cast<uint8_t>(c));
+            feed(c);
+        }
+    }
+
+    void feed(uint8_t octet) {
+        if (index_ >= buffer_.size()) {
+            reset();
+            return;
+        }
+        buffer_[index_] = octet;
+        if (state_ == State::Idle) {
+            state_ = State::UntilLength;
+            fill_ = 0;
+        }
+        if (state_ == State::UntilLength) {
+            bool header_complete = false;
+            if constexpr (Format == SxiHeaderFormat::LenByte) {
+                if (index_ == 0) {
+                    dlc_            = buffer_[0];
+                    remaining_      = dlc_;
+                    header_complete = true;
+                }
+            } else if constexpr (Format == SxiHeaderFormat::LenCtrByte || Format == SxiHeaderFormat::LenFillByte) {
+                if (index_ == 1) {
+                    dlc_            = buffer_[0];
+                    if constexpr (Format == SxiHeaderFormat::LenCtrByte) {
+                        ctr_ = buffer_[1];
+                    }
+                    remaining_      = dlc_;
+                    header_complete = true;
+                }
+            } else if constexpr (Format == SxiHeaderFormat::LenWord) {
+                if (index_ == 1) {
+                    dlc_            = detail::make_word_le(&buffer_[0]);
+                    remaining_      = dlc_;
+                    header_complete = true;
+                }
+            } else if constexpr (Format == SxiHeaderFormat::LenCtrWord || Format == SxiHeaderFormat::LenFillWord) {
+                if (index_ == 3) {
+                    dlc_            = detail::make_word_le(&buffer_[0]);
+                    if constexpr (Format == SxiHeaderFormat::LenCtrWord) {
+                        ctr_ = detail::make_word_le(&buffer_[2]);
+                    }
+                    remaining_      = dlc_;
+                    header_complete = true;
+                }
+            }
+            if (header_complete) {
+                if constexpr (Checksum == SxiChecksumType::Sum8) {
+                    remaining_ += 1;
+                } else if constexpr (Checksum == SxiChecksumType::Sum16) {
+                    uint16_t header_size = 0;
+                    if constexpr (Format == SxiHeaderFormat::LenByte) header_size = 1;
+                    else if constexpr (Format == SxiHeaderFormat::LenCtrByte || Format == SxiHeaderFormat::LenFillByte) header_size = 2;
+                    else if constexpr (Format == SxiHeaderFormat::LenWord) header_size = 2;
+                    else if constexpr (Format == SxiHeaderFormat::LenCtrWord || Format == SxiHeaderFormat::LenFillWord) header_size = 4;
+
+                    fill_ = ((header_size + dlc_) % 2 != 0) ? 1u : 0u;
+                    remaining_ += (2 + fill_);
+                }
+                state_ = State::Remaining;
+                if (remaining_ != 0) {
+                    index_++;
+                    return;
+                }
+            }
+        }
+        if (state_ == State::Remaining) {
+            if (remaining_ > 0) {
+                remaining_--;
+            }
+            if (remaining_ == 0) {
+                uint16_t payload_off = 0;
+                if constexpr (Format == SxiHeaderFormat::LenByte) {
+                    payload_off = 1;
+                } else if constexpr (Format == SxiHeaderFormat::LenCtrByte || Format == SxiHeaderFormat::LenFillByte) {
+                    payload_off = 2;
+                } else if constexpr (Format == SxiHeaderFormat::LenWord) {
+                    payload_off = 2;
+                } else if constexpr (Format == SxiHeaderFormat::LenCtrWord || Format == SxiHeaderFormat::LenFillWord) {
+                    payload_off = 4;
+                }
+
+                // verify checksum
+                if constexpr (Checksum == SxiChecksumType::Sum8) {
+                    uint8_t sum = 0;
+                    for (uint16_t i = 0; i < (payload_off + dlc_ + fill_); ++i) {
+                        sum += buffer_[i];
+                    }
+                    uint8_t rx = buffer_[payload_off + dlc_];
+                    if (sum != rx) {
+                        log_checksum_error(sum, rx, payload_off + dlc_ + 1);
+                        reset();
+                        return;
+                    }
+                } else if constexpr (Checksum == SxiChecksumType::Sum16) {
+                    uint16_t           count = (payload_off + dlc_ + fill_);
+                    uint16_t sum      = 0;
+
+                    for (uint16_t idx = 0; idx < count; idx += 2) {
+                        sum = static_cast<uint16_t>(sum + detail::make_word_le(&buffer_[idx]));
+                    }
+                    uint16_t rx = detail::make_word_le(&buffer_[payload_off + dlc_ + fill_]);
+                    if (sum != rx) {
+                        log_checksum_error(sum, rx, payload_off + dlc_ + fill_ + 2);
+                        reset();
+                        return;
+                    }
+                }
+                if (dispatch_) {
+                    dispatch_({ buffer_.data() + payload_off, buffer_.data() + payload_off + dlc_ }, dlc_, ctr_);
+                    #if defined(XCP_TL_TEST_HOOKS)
+                    std::fill(buffer_.begin(), buffer_.end(), 0xcc);
+                    #endif
+                }
+                reset();
+                return;
+            }
+        }
+        index_++;
+    }
+
+   private:
+
+    enum class State {
+        Idle,
+        UntilLength,
+        Remaining
+    };
+
+    template<typename T>
+    void log_checksum_error(T calculated, T received, uint16_t packet_len) {
+        std::cerr << "SXI checksum error: Calculated " << std::hex << "0x" << static_cast<int>(calculated)
+                  << ", but received " << "0x" << static_cast<int>(received) << "." << std::dec << std::endl;
+        std::cerr << "Packet dump (" << packet_len << " bytes):" << std::endl;
+        std::cerr << "[";
+        std::ios_base::fmtflags flags(std::cerr.flags()); // save flags
+        for (uint16_t i = 0; i < packet_len; ++i) {
+            std::cerr << std::hex << std::setw(2) << std::setfill('0') << static_cast<int>(buffer_[i]) << " ";
+            if ((i + 1) % 16 == 0) {
+                std::cerr << std::endl;
+            }
+        }
+        std::cerr << "]" << std::endl;
+        std::cerr.flags(flags); // restore flags
+    }
+
+    void reset() {
+        state_     = State::Idle;
+        index_     = 0;
+        dlc_       = 0;
+        remaining_ = 0;
+        ctr_       = 0;
+        fill_       = 0;
+        #if defined(XCP_TL_TEST_HOOKS)
+        std::fill(buffer_.begin(), buffer_.end(), 0xcc);
+        #endif
+    }
+
+    std::array<uint8_t, 1024>                        buffer_{};
+    State                                            state_{ State::Idle };
+    uint32_t                                         index_{ 0 };
+    uint16_t                                         dlc_{ 0 };
+    uint16_t                                         ctr_{ 0 };
+    uint32_t                                         remaining_{ 0 };
+    uint16_t                                         fill_ {0};
+    std::function<void(const std::vector<uint8_t>&, uint16_t, uint16_t)> dispatch_;
+};
+
+#endif // __SXI_FRAMING_HPP

pyxcp/daq_stim/__init__.py

@@ -1,12 +1,14 @@
 #!/usr/bin/env python
 
-# from pprint import pprint
+from contextlib import suppress
+import json
 from time import time_ns
-from typing import Dict, List, Optional, TextIO
+from typing import Any, Dict, List, Optional, TextIO, Tuple, Union
+
+from pyxcp.cpp_ext.cpp_ext import DaqList, PredefinedDaqList
 
 from pyxcp import types
 from pyxcp.config import get_application
-from pyxcp.cpp_ext.cpp_ext import DaqList
 from pyxcp.daq_stim.optimize import make_continuous_blocks
 from pyxcp.daq_stim.optimize.binpacking import first_fit_decreasing
 from pyxcp.recorder import DaqOnlinePolicy as _DaqOnlinePolicy
@@ -14,7 +16,6 @@ from pyxcp.recorder import DaqRecorderPolicy as _DaqRecorderPolicy
 from pyxcp.recorder import MeasurementParameters
 from pyxcp.utils import CurrentDatetime
 
-
 DAQ_ID_FIELD_SIZE = {
     "IDF_ABS_ODT_NUMBER": 1,
     "IDF_REL_ODT_NUMBER_ABS_DAQ_LIST_NUMBER_BYTE": 2,
@@ -29,9 +30,87 @@ DAQ_TIMESTAMP_SIZE = {
 }
 
 
+def load_daq_lists_from_json(file_path: str) -> List[DaqList]:
+    """Load and validate DAQ-list from JSON file."""
+    with open(file_path, "r", encoding="utf-8") as f:
+        config = json.load(f)
+
+    if not isinstance(config, list):
+        raise ValueError("DAQ configuration must be a JSON array (list)")
+
+    daq_lists: List[DaqList] = []
+    for idx, entry in enumerate(config):
+        if not isinstance(entry, dict):
+            raise TypeError(f"Entry {idx} must be an object/dict")
+
+        required = {"name", "event_num", "stim", "enable_timestamps", "measurements", "priority", "prescaler"}
+        missing = required - set(entry.keys())
+        if missing:
+            raise ValueError(f"Entry {idx} missing required keys: {missing}")
+
+        # Basic type conversions / checks
+        name = entry["name"]
+        if not isinstance(name, str):
+            raise TypeError(f"Entry {idx} 'name' must be a string")
+
+        try:
+            event_num = int(entry["event_num"])
+        except Exception as e:
+            raise TypeError(f"Entry {idx} 'event_num' must be an integer") from e
+
+        stim = bool(entry["stim"])
+        enable_timestamps = bool(entry["enable_timestamps"])
+
+        try:
+            priority = int(entry["priority"])
+            prescaler = int(entry["prescaler"])
+        except Exception as e:
+            raise TypeError(f"Entry {idx} 'priority' and 'prescaler' must be integers") from e
+
+        measurements_raw = entry["measurements"]
+        if not isinstance(measurements_raw, list):
+            raise TypeError(f"Entry {idx} 'measurements' must be a list")
+
+        measurements: List[Tuple[str, int, int, str]] = []
+        for m_idx, m in enumerate(measurements_raw):
+            if not (isinstance(m, (list, tuple)) and len(m) == 4):
+                raise ValueError(f"Entry {idx} measurement {m_idx} must be a 4-element list/tuple")
+            m_name, m_addr, m_offset, m_type = m
+
+            if not isinstance(m_name, str):
+                raise TypeError(f"Entry {idx} measurement {m_idx} name must be a string")
+            try:
+                m_addr = int(m_addr)
+            except Exception as e:
+                raise TypeError(f"Entry {idx} measurement {m_idx} address must be an integer") from e
+            try:
+                m_offset = int(m_offset)
+            except Exception as e:
+                raise TypeError(f"Entry {idx} measurement {m_idx} offset must be an integer") from e
+            if not isinstance(m_type, str):
+                raise TypeError(f"Entry {idx} measurement {m_idx} type must be a string")
+
+            measurements.append((m_name, m_addr, m_offset, m_type))
+
+        daq_kwargs: Dict[str, Any] = {
+            "name": name,
+            "event_num": event_num,
+            "stim": stim,
+            "enable_timestamps": enable_timestamps,
+            "measurements": measurements,
+            "priority": priority,
+            "prescaler": prescaler,
+        }
+
+        daq_lists.append(DaqList(**daq_kwargs))
+
+    return daq_lists
+
+
 class DaqProcessor:
-    def __init__(self, daq_lists: List[DaqList]):
+    def __init__(self, daq_lists: List[Union[DaqList, PredefinedDaqList]]):
         self.daq_lists = daq_lists
+        self.is_predefined = [isinstance(d, PredefinedDaqList) for d in daq_lists]
         self.log = get_application().log
         # Flag indicating a fatal OS-level error occurred during DAQ (e.g., disk full, out-of-memory)
         self._fatal_os_error: bool = False
@@ -43,13 +122,14 @@ class DaqProcessor:
         if start_datetime is None:
             start_datetime = CurrentDatetime(time_ns())
         self.start_datetime = start_datetime
-        # print(self.start_datetime)
         try:
             processor = self.daq_info.get("processor")
             properties = processor.get("properties")
             resolution = self.daq_info.get("resolution")
-            if properties["configType"] == "STATIC":
-                raise TypeError("DAQ configuration is static, cannot proceed.")
+            if properties["configType"] == "STATIC" and not all(self.is_predefined):
+                raise TypeError(
+                    "DAQ configuration is static, but in your configuration are only dynamic DAQ lists -- cannot proceed."
+                )
             self.supports_timestampes = properties["timestampSupported"]
             self.supports_prescaler = properties["prescalerSupported"]
             self.supports_pid_off = properties["pidOffSupported"]
@@ -72,22 +152,24 @@ class DaqProcessor:
             max_payload_size = min(max_odt_entry_size, max_dto - header_len)
             # First ODT may contain timestamp.
             self.selectable_timestamps = False
+            max_payload_size_first = max_payload_size
             if not self.supports_timestampes:
-                max_payload_size_first = max_payload_size
-                # print("NO TIMESTAMP SUPPORT")
+                self.log.info("No timestamp support")
             else:
                 if self.ts_fixed:
-                    # print("Fixed timestamp")
+                    self.log.debug("Fixed timestamps")
                     max_payload_size_first = max_payload_size - self.ts_size
                 else:
-                    # print("timestamp variable.")
+                    self.log.debug("Variable timestamps.")
                     self.selectable_timestamps = True
-
         except Exception as e:
             raise TypeError(f"DAQ_INFO corrupted: {e}") from e
 
         # DAQ optimization.
-        for daq_list in self.daq_lists:
+        # For dynamic DaqList instances, compute physical layout; skip for PredefinedDaqList.
+        for idx, daq_list in enumerate(self.daq_lists):
+            if isinstance(daq_list, PredefinedDaqList):
+                continue
             if self.selectable_timestamps:
                 if daq_list.enable_timestamps:
                     max_payload_size_first = max_payload_size - self.ts_size
@@ -98,34 +180,47 @@ class DaqProcessor:
         byte_order = 0 if self.xcp_master.slaveProperties.byteOrder == "INTEL" else 1
         self._first_pids = []
         daq_count = len(self.daq_lists)
-        self.xcp_master.freeDaq()
-
-        # Allocate
-        self.xcp_master.allocDaq(daq_count)
-        measurement_list = []
-        for i, daq_list in enumerate(self.daq_lists, self.min_daq):
-            measurements = daq_list.measurements_opt
-            measurement_list.append((i, measurements))
-            odt_count = len(measurements)
-            self.xcp_master.allocOdt(i, odt_count)
-        # Iterate again over ODT entries -- we need to respect sequencing requirements.
-        for i, measurements in measurement_list:
-            for j, measurement in enumerate(measurements):
-                entry_count = len(measurement.entries)
-                self.xcp_master.allocOdtEntry(i, j, entry_count)
-        # Write DAQs
-        for i, daq_list in enumerate(self.daq_lists, self.min_daq):
-            measurements = daq_list.measurements_opt
-            for j, measurement in enumerate(measurements):
-                if len(measurement.entries) == 0:
-                    continue  # CAN special case: No room for data in first ODT.
-                self.xcp_master.setDaqPtr(i, j, 0)
-                for entry in measurement.entries:
-                    self.xcp_master.writeDaq(0xFF, entry.length, entry.ext, entry.address)
+
+        # Decide whether DAQ allocation must be performed.
+        config_static = self.daq_info.get("processor", {}).get("properties", {}).get("configType") == "STATIC"
+
+        if not config_static:
+            # For dynamic configuration, program only dynamic (non-predefined) DAQ lists.
+            self.xcp_master.freeDaq()
+            # Allocate the number of DAQ lists required.
+            self.xcp_master.allocDaq(daq_count)
+            measurement_list = []
+            for i, daq_list in enumerate(self.daq_lists, self.min_daq):
+                if isinstance(daq_list, PredefinedDaqList):
+                    # Skip allocation for predefined DAQ lists.
+                    continue
+                measurements = daq_list.measurements_opt
+                measurement_list.append((i, measurements))
+                odt_count = len(measurements)
+                self.xcp_master.allocOdt(i, odt_count)
+            # Iterate again over ODT entries -- we need to respect sequencing requirements.
+            for i, measurements in measurement_list:
+                for j, measurement in enumerate(measurements):
+                    entry_count = len(measurement.entries)
+                    self.xcp_master.allocOdtEntry(i, j, entry_count)
+            # Write DAQs (only for dynamic lists)
+            for i, daq_list in enumerate(self.daq_lists, self.min_daq):
+                if isinstance(daq_list, PredefinedDaqList):
+                    continue
+                measurements = daq_list.measurements_opt
+                for j, measurement in enumerate(measurements):
+                    if len(measurement.entries) == 0:
+                        continue  # CAN special case: No room for data in first ODT.
+                    self.xcp_master.setDaqPtr(i, j, 0)
+                    for entry in measurement.entries:
+                        self.xcp_master.writeDaq(0xFF, entry.length, entry.ext, entry.address)
+        else:
+            # STATIC configuration on the slave: skip allocation and programming; lists/ODTs are predefined.
+            pass
 
         # arm DAQ lists -- this is technically a function on its own.
-        for i, daq_list in enumerate(self.daq_lists, self.min_daq):
-            # print(daq_list.name, daq_list.event_num, daq_list.stim)
+        first_daq_list = 0 if config_static else self.min_daq
+        for i, daq_list in enumerate(self.daq_lists, first_daq_list):
             mode = 0x00
             if self.supports_timestampes and (self.ts_fixed or (self.selectable_timestamps and daq_list.enable_timestamps)):
                 mode = 0x10
@@ -143,8 +238,6 @@ class DaqProcessor:
             )
             res = self.xcp_master.startStopDaqList(0x02, i)
             self._first_pids.append(res.firstPid)
-        if start_datetime:
-            pass
         self.measurement_params = MeasurementParameters(
             byte_order,
             header_len,
@@ -168,26 +261,21 @@ class DaqProcessor:
         # If a fatal OS error occurred during acquisition, skip sending stop to the slave to avoid
         # cascading timeouts/unrecoverable errors and shut down transport gracefully instead.
         if getattr(self, "_fatal_os_error", False):
-            try:
+            with suppress(Exception):
                 self.log.error(
                     "DAQ stop skipped due to previous fatal OS error (e.g., disk full or out-of-memory). Closing transport."
                 )
-            except Exception:
-                pass
             try:
                 # Best-effort: stop listener and close transport so threads finish cleanly.
                 if hasattr(self.xcp_master, "transport") and self.xcp_master.transport is not None:
                     # Signal listeners to stop
-                    try:
+                    with suppress(Exception):
                         if hasattr(self.xcp_master.transport, "closeEvent"):
                             self.xcp_master.transport.closeEvent.set()
-                    except Exception:
-                        pass
+
                     # Close transport connection
-                    try:
+                    with suppress(Exception):
                         self.xcp_master.transport.close()
-                    except Exception:
-                        pass
             finally:
                 return
         self.xcp_master.startStopSynch(0x00)
@@ -197,7 +285,6 @@ class DaqProcessor:
 
 
 class DaqRecorder(DaqProcessor, _DaqRecorderPolicy):
-
     def __init__(self, daq_lists: List[DaqList], file_name: str, prealloc: int = 200, chunk_size: int = 1):
         DaqProcessor.__init__(self, daq_lists)
         _DaqRecorderPolicy.__init__(self)
@@ -253,30 +340,21 @@ class DaqToCsv(DaqOnlinePolicy):
         except (OSError, MemoryError) as ex:
             # Mark fatal condition to alter shutdown path and avoid further writes/commands.
             self._fatal_os_error = True
-            try:
+            with suppress(Exception):
                 self.log.critical(f"DAQ file write failed: {ex.__class__.__name__}: {ex}. Initiating graceful shutdown.")
-            except Exception:
-                pass
+
             # Stop listener to prevent more DAQ traffic and avoid thread crashes.
-            try:
+            with suppress(Exception):
                 if hasattr(self.xcp_master, "transport") and self.xcp_master.transport is not None:
                     if hasattr(self.xcp_master.transport, "closeEvent"):
                         self.xcp_master.transport.closeEvent.set()
-            except Exception:
-                pass
             # Best-effort: close any opened files to flush buffers and release resources.
-            try:
+            with suppress(Exception):
                 for f in getattr(self, "files", {}).values():
-                    try:
+                    with suppress(Exception):
                         f.flush()
-                    except Exception:
-                        pass
-                    try:
+                    with suppress(Exception):
                         f.close()
-                    except Exception:
-                        pass
-            except Exception:
-                pass
             # Do not re-raise; allow the system to continue to a controlled shutdown.
             return
 

pyxcp/daq_stim/optimize/binpacking.py

@@ -1,6 +1,6 @@
 #!/usr/bin/env python
-"""Bin-packing algorithms.
-"""
+"""Bin-packing algorithms."""
+
 from typing import List, Optional
 
 from pyxcp.cpp_ext.cpp_ext import Bin