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

pyxcp/cpp_ext/aligned_buffer.hpp

@@ -0,0 +1,168 @@
+
+#if !defined(__ALIGNED_BUFFER_HPP)
+#define __ALIGNED_BUFFER_HPP
+
+#include <variant>
+
+#include <cstdint>
+#include <cstdlib>
+#include <vector>
+#include <string_view>
+#include <stdexcept>
+#include <algorithm>
+#include <cstring>
+
+#include <pybind11/pybind11.h>
+
+#if (defined(_WIN32) || defined(_WIN64)) && defined(_MSC_VER)
+    #include <malloc.h>
+#endif
+
+namespace py = pybind11;
+
+class AlignedBuffer {
+
+public:
+
+    AlignedBuffer(size_t size = 0xffff) : m_size(size), m_current_pos(0)  {
+        m_buffer = nullptr;
+        // Create naturally aligned buffer.
+        constexpr std::size_t align = alignof(int);
+        // aligned_alloc requires size to be a multiple of alignment.
+        const std::size_t aligned_size = ((m_size + align - 1) / align) * align;
+        #if (defined(_WIN32) || defined(_WIN64)) && defined(_MSC_VER)
+        m_buffer = static_cast<uint8_t*>(::_aligned_malloc(aligned_size, align));
+        #else
+        m_buffer = static_cast<uint8_t*>(::aligned_alloc(align, aligned_size));
+        #endif
+    }
+
+    AlignedBuffer(const AlignedBuffer& other) = delete;
+    AlignedBuffer& operator=(const AlignedBuffer& other) = delete;
+    AlignedBuffer(AlignedBuffer&& other) = delete;
+    AlignedBuffer& operator=(AlignedBuffer&& other) = delete;
+
+    ~AlignedBuffer() {
+        if (m_buffer) {
+            #if (defined(_WIN32) || defined(_WIN64)) && defined(_MSC_VER)
+            ::_aligned_free(m_buffer);
+            #else
+            ::free(m_buffer);
+            #endif
+            m_buffer = nullptr;
+        }
+    }
+
+    void reset() noexcept  {
+        m_current_pos = 0;
+    }
+
+    std::size_t size() const noexcept {
+        return m_current_pos;
+    }
+
+        // Get an element by index
+    uint8_t get(size_t index) const {
+        if (index >= size()) throw std::out_of_range("Index out of range");
+        return m_buffer[index];
+    }
+
+    void append(uint8_t value) {
+        if ((m_current_pos + 1) > m_size) {
+            throw std::overflow_error("Buffer overflow");
+        }
+        m_buffer[m_current_pos] = value;
+        m_current_pos++;
+    }
+
+    // Set an element by index
+    void set(size_t index, uint8_t value) {
+        if (index >= size()) throw std::out_of_range("Index out of range");
+        m_buffer[index] = value;
+    }
+
+    static std::string_view bytes_as_string_view(const py::bytes& data) {
+        char* buf = nullptr;
+        Py_ssize_t len = 0;
+        if (PyBytes_AsStringAndSize(data.ptr(), &buf, &len) != 0 || buf == nullptr || len < 0) {
+            return std::string_view{};
+        }
+        return std::string_view(buf, static_cast<std::size_t>(len));
+    }
+
+
+    void extend(const py::bytes& values)  {
+        auto data_view = bytes_as_string_view(values);
+
+        if ((data_view.size() + m_current_pos) > m_size) {
+            throw std::invalid_argument("Values vector is too large");
+        }
+        if (!data_view.empty()) {
+            std::memcpy(m_buffer + m_current_pos, data_view.data(), data_view.size());
+            m_current_pos += data_view.size();
+        }
+	}
+
+	void extend(const std::vector<std::uint8_t>& values)  {
+        if ((values.size() + m_current_pos) > m_size) {
+            throw std::invalid_argument("Values vector is too large");
+        }
+        if (!values.empty()) {
+            std::memcpy(m_buffer + m_current_pos, values.data(), values.size());
+            m_current_pos += values.size();
+        }
+	}
+
+    std::variant<uint8_t, py::bytes> get_item(py::object index) const {
+        if (py::isinstance<py::slice>(index)) {
+            py::slice slice = index.cast<py::slice>();
+            size_t start, stop, step, length;
+            if (!slice.compute(size(), &start, &stop, &step, &length)) {
+                throw py::error_already_set();
+            }
+            return slice(start, stop, step);
+        } else if (py::isinstance<py::int_>(index)) {
+            Py_ssize_t idx = index.cast<Py_ssize_t>();
+            if (idx < 0) {
+                idx += static_cast<Py_ssize_t>(size());
+            }
+            if (idx < 0 || static_cast<std::size_t>(idx) >= size()) {
+                throw std::out_of_range("Index out of range");
+            }
+            return get(static_cast<std::size_t>(idx));
+        } else {
+            throw py::type_error("Invalid index type");
+        }
+    }
+
+    py::bytes slice(size_t start, size_t stop, size_t step) const {
+        if (step == 0) {
+            throw std::invalid_argument("Step cannot be zero");
+        }
+        // Clamp indices to valid range
+        start = std::max(size_t(0), std::min(start, size_t(size())));
+        stop = std::max(size_t(0), std::min(stop, size_t(size())));
+
+        if (start >= stop) {
+            return py::bytes("");
+        }
+        if (step == 1) {
+            return py::bytes(reinterpret_cast<const char*>(m_buffer) + start, stop - start);
+        }
+        // General step handling (build result with stride)
+        std::string out;
+        out.reserve((stop - start + step - 1) / step);
+        for (size_t i = start; i < stop; i += step) {
+            out.push_back(static_cast<char>(m_buffer[i]));
+        }
+        return py::bytes(out);
+    }
+
+private:
+    size_t m_size;
+    size_t m_current_pos;
+    uint8_t * m_buffer;
+};
+
+
+#endif // __ALIGNED_BUFFER_HPP

pyxcp/cpp_ext/bin.hpp

@@ -79,17 +79,18 @@ std::string bin_entries_to_string(const std::vector<McObject>& entries);
 
 std::string to_string(const Bin& obj) {
     std::stringstream ss;
-
-    ss << "Bin(residual_capacity=" << obj.get_residual_capacity() << ", entries=[" << bin_entries_to_string(obj.get_entries())
-       << "])";
+    ss << "Bin(size=" << obj.get_size() << ", residual_capacity=" << obj.get_residual_capacity() << ", entries=["
+       << bin_entries_to_string(obj.get_entries()) << "])";
     return ss.str();
 }
 
 std::string bin_entries_to_string(const std::vector<McObject>& entries) {
     std::stringstream ss;
-
-    for (const auto& entry : entries) {
-        ss << to_string(entry) << ",\n ";
+    for (std::size_t i = 0; i < entries.size(); ++i) {
+        ss << to_string(entries[i]);
+        if (i + 1 < entries.size()) {
+            ss << ", ";
+        }
     }
     return ss.str();
 }

pyxcp/cpp_ext/daqlist.hpp

@@ -8,22 +8,70 @@
 
 using flatten_odts_t = std::vector<std::vector<std::tuple<std::string, std::uint32_t, std::uint8_t, std::uint16_t, std::int16_t>>>;
 
-class DaqList {
+class Odt {
    public:
+    using odt_entry_initializer_t = std::tuple<std::string, std::string>;
 
-    using daq_list_initialzer_t = std::tuple<std::string, std::uint32_t, std::uint16_t, std::string>;
+    Odt(const std::vector<odt_entry_initializer_t>& entries) {
+        for (const auto& entry : entries) {
+            const auto& [name, dt_name] = entry;
+            m_entries.emplace_back(McObject(name, 0, 0, 0, dt_name));
+        }
+    }
 
-    DaqList(
-        std::string_view meas_name, std::uint16_t event_num, bool stim, bool enable_timestamps,
-        const std::vector<daq_list_initialzer_t>& measurements, std::uint8_t priority=0x00, std::uint8_t prescaler=0x01
-    ) :
-        m_name(meas_name), m_event_num(event_num), m_priority(priority), m_prescaler(prescaler), m_stim(stim), m_enable_timestamps(enable_timestamps) {
-        for (const auto& measurement : measurements) {
-            auto const& [name, address, ext, dt_name] = measurement;
-            m_measurements.emplace_back(McObject(name, address, static_cast<std::uint8_t>(ext), 0, dt_name));
+    const std::vector<McObject>& get_entries() const {
+        return m_entries;
+    }
+
+    std::string dumps() const {
+        std::stringstream ss;
+        ss << to_binary(m_entries.size());
+        for (const auto& entry : m_entries) {
+            ss << entry.dumps();
         }
+        return ss.str();
     }
 
+    std::string to_string() const {
+        std::stringstream ss;
+        ss << "Odt(entries=[";
+        for (std::size_t i = 0; i < m_entries.size(); ++i) {
+            ss << ::to_string(m_entries[i]);
+            if (i + 1 < m_entries.size()) {
+                ss << ", ";
+            }
+        }
+        ss << "])";
+        return ss.str();
+    }
+
+   private:
+    std::vector<McObject> m_entries;
+};
+
+inline std::string to_string(const Odt& odt) {
+    return odt.to_string();
+}
+
+class DaqListBase {
+   public:
+    DaqListBase(std::string_view name, std::uint16_t event_num, bool stim, bool enable_timestamps, std::uint8_t priority, std::uint8_t prescaler) :
+        m_name(name),
+        m_event_num(event_num),
+        m_priority(priority),
+        m_prescaler(prescaler),
+        m_stim(stim),
+        m_enable_timestamps(enable_timestamps),
+        m_odt_count(0),
+        m_total_entries(0),
+        m_total_length(0) {
+    }
+
+    virtual ~DaqListBase() = default;
+
+    virtual std::string dumps() const = 0;
+    virtual std::string to_string() const = 0;
+
     bool get_enable_timestamps() const {
         return m_enable_timestamps;
     }
@@ -52,10 +100,6 @@ class DaqList {
         return m_stim;
     }
 
-    const std::vector<McObject>& get_measurements() const {
-        return m_measurements;
-    }
-
     const std::vector<Bin>& get_measurements_opt() const {
         return m_measurements_opt;
     }
@@ -86,6 +130,10 @@ class DaqList {
 
     void set_measurements_opt(const std::vector<Bin>& measurements_opt) {
         m_measurements_opt = measurements_opt;
+        m_header_names.clear();
+        m_headers.clear();
+        m_flatten_odts.clear();
+
         auto odt_count     = 0u;
         auto total_entries = 0u;
         auto total_length  = 0u;
@@ -93,31 +141,85 @@ class DaqList {
             odt_count++;
             std::vector<std::tuple<std::string, std::uint32_t, std::uint8_t, std::uint16_t, std::int16_t>> flatten_odt{};
             for (const auto& mc_obj : bin.get_entries()) {
-                for (const auto& component : mc_obj.get_components()) {
-                    m_header_names.emplace_back(component.get_name());
+                const auto& components = mc_obj.get_components();
+                if (!components.empty()) {
+                    for (const auto& component : components) {
+                        m_header_names.emplace_back(component.get_name());
+                        flatten_odt.emplace_back(
+                            component.get_name(), component.get_address(), component.get_ext(), component.get_length(),
+                            component.get_type_index()
+                        );
+                        // TYPE_MAP_REV::at may throw if key is invalid; this indicates a programming error upstream.
+                        m_headers.emplace_back(component.get_name(), TYPE_MAP_REV.at(static_cast<std::uint16_t>(component.get_type_index())));
+                        total_entries++;
+                        total_length += component.get_length();
+                    }
+                } else {
+                    // Treat the McObject itself as an entry when it has no components.
+                    m_header_names.emplace_back(mc_obj.get_name());
                     flatten_odt.emplace_back(
-                        component.get_name(), component.get_address(), component.get_ext(), component.get_length(),
-                        component.get_type_index()
+                        mc_obj.get_name(), mc_obj.get_address(), mc_obj.get_ext(), mc_obj.get_length(), mc_obj.get_type_index()
                     );
-                    m_headers.emplace_back(component.get_name(), TYPE_MAP_REV.at(component.get_type_index()));
+                    m_headers.emplace_back(mc_obj.get_name(), TYPE_MAP_REV.at(static_cast<std::uint16_t>(mc_obj.get_type_index())));
                     total_entries++;
-                    total_length += component.get_length();
+                    total_length += mc_obj.get_length();
                 }
             }
-            m_flatten_odts.emplace_back(flatten_odt);
+            m_flatten_odts.emplace_back(std::move(flatten_odt));
         }
-        m_odt_count     = odt_count;
-        m_total_entries = total_entries;
-        m_total_length  = total_length;
+        m_odt_count     = static_cast<std::uint16_t>(odt_count);
+        m_total_entries = static_cast<std::uint16_t>(total_entries);
+        m_total_length  = static_cast<std::uint16_t>(total_length);
     }
 
-    std::string dumps() const {
+   protected:
+    std::string                                       m_name;
+    std::uint16_t                                     m_event_num;
+    std::uint8_t                                      m_priority;
+    std::uint8_t                                      m_prescaler;
+    bool                                              m_stim;
+    bool                                              m_enable_timestamps;
+    std::vector<Bin>                                  m_measurements_opt;
+    std::vector<std::string>                          m_header_names;
+    std::vector<std::tuple<std::string, std::string>> m_headers;
+    std::uint16_t                                     m_odt_count;
+    std::uint16_t                                     m_total_entries;
+    std::uint16_t                                     m_total_length;
+    flatten_odts_t                                    m_flatten_odts;
+};
+
+class DaqList : public DaqListBase {
+   public:
+
+    using daq_list_initialzer_t = std::tuple<std::string, std::uint32_t, std::uint16_t, std::string>;
+
+    DaqList(
+        std::string_view meas_name, std::uint16_t event_num, bool stim, bool enable_timestamps,
+        const std::vector<daq_list_initialzer_t>& measurements, std::uint8_t priority=0x00, std::uint8_t prescaler=0x01
+    ) :
+        DaqListBase(meas_name, event_num, stim, enable_timestamps, priority, prescaler) {
+        for (const auto& measurement : measurements) {
+            auto const& [name, address, ext, dt_name] = measurement;
+            m_measurements.emplace_back(McObject(name, address, static_cast<std::uint8_t>(ext), 0, dt_name));
+        }
+    }
+
+    const std::vector<McObject>& get_measurements() const {
+        return m_measurements;
+    }
+
+    std::string dumps() const override {
         std::stringstream ss;
 
+		std::uint8_t discr=1;
+
+        ss << to_binary(discr);
         ss << to_binary(m_name);
         ss << to_binary(m_event_num);
         ss << to_binary(m_stim);
         ss << to_binary(m_enable_timestamps);
+        ss << to_binary(m_priority);
+        ss << to_binary(m_prescaler);
 
         ss << to_binary(m_odt_count);
         ss << to_binary(m_total_entries);
@@ -138,47 +240,39 @@ class DaqList {
         for (const auto& hdr_obj : m_header_names) {
             ss << to_binary(hdr_obj);
         }
-        /////
-        std::size_t odt_size = m_flatten_odts.size();
-        ss << to_binary(odt_size);
-        for (const auto& odt : m_flatten_odts) {
-            ss << to_binary(odt.size());
-            for (const auto& odt_entry : odt) {
-                const auto& [name, address, ext, size, type_index] = odt_entry;
-                ss << to_binary(name);
-                ss << to_binary(address);
-                ss << to_binary(ext);
-                ss << to_binary(size);
-                ss << to_binary(type_index);
-            }
-        }
         return ss.str();
     }
 
-    std::string to_string() const {
+    std::string to_string() const override {
         std::stringstream ss;
-
         ss << "DaqList(";
-        ss << "name=\"" << m_name << "\", ";
+        ss << "name='" << m_name << "', ";
         ss << "event_num=" << static_cast<std::uint16_t>(m_event_num) << ", ";
         ss << "stim=" << bool_to_string(m_stim) << ", ";
-        ss << "enable_timestamps" << bool_to_string(m_enable_timestamps) << ", ";
-        ss << "measurements=[\n";
-        for (const auto& meas : m_measurements) {
-            ss << ::to_string(meas) << ",\n";
-        }
-        ss << "],\n";
-        ss << "measurements_opt=[\n";
-        for (const auto& meas : m_measurements_opt) {
-            ss << ::to_string(meas) << ",\n";
-        }
-        ss << "],\n";
-        ss << "header_names=[\n";
-        for (const auto& header : m_header_names) {
-            ss << "\"" << header << "\",";
-        }
-        ss << "\n]";
-        ss << ")";
+        ss << "enable_timestamps=" << bool_to_string(m_enable_timestamps) << ", ";
+        ss << "priority=" << static_cast<std::uint16_t>(m_priority) << ", ";
+        ss << "prescaler=" << static_cast<std::uint16_t>(m_prescaler) << ", ";
+        ss << "odt_count=" << static_cast<std::uint16_t>(m_odt_count) << ", ";
+        ss << "total_entries=" << static_cast<std::uint16_t>(m_total_entries) << ", ";
+        ss << "total_length=" << static_cast<std::uint16_t>(m_total_length) << ", ";
+        ss << "measurements=[";
+        for (std::size_t i = 0; i < m_measurements.size(); ++i) {
+            ss << ::to_string(m_measurements[i]);
+            if (i + 1 < m_measurements.size()) ss << ", ";
+        }
+        ss << "], ";
+        ss << "measurements_opt=[";
+        for (std::size_t i = 0; i < m_measurements_opt.size(); ++i) {
+            ss << ::to_string(m_measurements_opt[i]);
+            if (i + 1 < m_measurements_opt.size()) ss << ", ";
+        }
+        ss << "], ";
+        ss << "header_names=[";
+        for (std::size_t i = 0; i < m_header_names.size(); ++i) {
+            ss << "'" << m_header_names[i] << "'";
+            if (i + 1 < m_header_names.size()) ss << ", ";
+        }
+        ss << "])";
         return ss.str();
     }
 
@@ -186,21 +280,95 @@ class DaqList {
     }
 
    private:
+    std::vector<McObject> m_measurements;
+};
 
-    std::string                                       m_name;
-    std::uint16_t                                     m_event_num;
-    std::uint8_t                                      m_priority;
-    std::uint8_t                                      m_prescaler;
-    bool                                              m_stim;
-    bool                                              m_enable_timestamps;
-    std::vector<McObject>                             m_measurements;
-    std::vector<Bin>                                  m_measurements_opt;
-    std::vector<std::string>                          m_header_names;
-    std::vector<std::tuple<std::string, std::string>> m_headers;
-    std::uint16_t                                     m_odt_count;
-    std::uint16_t                                     m_total_entries;
-    std::uint16_t                                     m_total_length;
-    flatten_odts_t                                    m_flatten_odts;
+class PredefinedDaqList : public DaqListBase {
+   public:
+    using odt_initializer_t = std::vector<Odt::odt_entry_initializer_t>;
+    using predefined_daq_list_initializer_t = std::vector<odt_initializer_t>;
+
+    PredefinedDaqList(
+        std::string_view name, std::uint16_t event_num, bool stim, bool enable_timestamps,
+        const predefined_daq_list_initializer_t& odts, std::uint8_t priority = 0x00, std::uint8_t prescaler = 0x01) :
+        DaqListBase(name, event_num, stim, enable_timestamps, priority, prescaler) {
+        std::vector<Bin> bins;
+        bins.reserve(odts.size());
+        for (const auto& odt_init : odts) {
+            Bin bin(0);
+            std::uint16_t total_length = 0;
+            for (const auto& entry : odt_init) {
+                const auto& [name, dt_name] = entry;
+                // McObject will validate dt_name and set length accordingly.
+                McObject obj(name, 0, 0, 0, dt_name);
+                total_length = static_cast<std::uint16_t>(total_length + obj.get_length());
+                bin.append(obj);
+            }
+            // Derive Bin size and residual capacity from sum of entry lengths.
+            bin.set_size(total_length);
+            bin.set_residual_capacity(total_length);
+            bins.emplace_back(std::move(bin));
+        }
+        set_measurements_opt(bins);
+    }
+
+    std::string dumps() const override {
+        std::stringstream ss;
+
+		std::uint8_t discr=2;
+
+        ss <<  to_binary(discr);
+
+        ss << to_binary(m_name);
+        ss << to_binary(m_event_num);
+        ss << to_binary(m_stim);
+        ss << to_binary(m_enable_timestamps);
+        ss << to_binary(m_priority);
+        ss << to_binary(m_prescaler);
+
+        ss << to_binary(m_odt_count);
+        ss << to_binary(m_total_entries);
+        ss << to_binary(m_total_length);
+
+        std::size_t meas_opt_size = m_measurements_opt.size();
+        ss << to_binary(meas_opt_size);
+        for (const auto& mc_obj : m_measurements_opt) {
+            ss << mc_obj.dumps();
+        }
+        std::size_t hname_size = m_header_names.size();
+        ss << to_binary(hname_size);
+        for (const auto& hdr_obj : m_header_names) {
+            ss << to_binary(hdr_obj);
+        }
+        return ss.str();
+    }
+
+    std::string to_string() const override {
+        std::stringstream ss;
+        ss << "PredefinedDaqList(";
+        ss << "name='" << m_name << "', ";
+        ss << "event_num=" << static_cast<std::uint16_t>(m_event_num) << ", ";
+        ss << "stim=" << bool_to_string(m_stim) << ", ";
+        ss << "enable_timestamps=" << bool_to_string(m_enable_timestamps) << ", ";
+        ss << "priority=" << static_cast<std::uint16_t>(m_priority) << ", ";
+        ss << "prescaler=" << static_cast<std::uint16_t>(m_prescaler) << ", ";
+        ss << "odt_count=" << static_cast<std::uint16_t>(m_odt_count) << ", ";
+        ss << "total_entries=" << static_cast<std::uint16_t>(m_total_entries) << ", ";
+        ss << "total_length=" << static_cast<std::uint16_t>(m_total_length) << ", ";
+        ss << "measurements_opt=[";
+        for (std::size_t i = 0; i < m_measurements_opt.size(); ++i) {
+            ss << ::to_string(m_measurements_opt[i]);
+            if (i + 1 < m_measurements_opt.size()) ss << ", ";
+        }
+        ss << "], ";
+        ss << "header_names=[";
+        for (std::size_t i = 0; i < m_header_names.size(); ++i) {
+            ss << "'" << m_header_names[i] << "'";
+            if (i + 1 < m_header_names.size()) ss << ", ";
+        }
+        ss << "])";
+        return ss.str();
+    }
 };
 
 #endif  // __DAQ_LIST_HPP