pyxcp 0.25.4__cp313-cp313-win_amd64.whl

pyxcp/config/legacy.py

@@ -0,0 +1,120 @@
+from collections import defaultdict
+
+from traitlets.config import LoggingConfigurable
+from traitlets.config.loader import Config
+
+
+LEGACY_KEYWORDS = {
+    # General
+    "LOGLEVEL": "General.loglevel",
+    "DISABLE_ERROR_HANDLING": "General.disable_error_handling",
+    "SEED_N_KEY_DLL": "General.seed_n_key_dll",
+    "SEED_N_KEY_DLL_SAME_BIT_WIDTH": "General.seed_n_key_dll_same_bit_width",
+    "DISCONNECT_RESPONSE_OPTIONAL": "General.disconnect_response_optional",
+    # Transport
+    "TRANSPORT": "Transport.layer",
+    "CREATE_DAQ_TIMESTAMPS": "Transport.create_daq_timestamps",
+    "TIMEOUT": "Transport.timeout",
+    "ALIGNMENT": "Transport.alignment",
+    # Eth
+    "HOST": "Transport.Eth.host",
+    "PORT": "Transport.Eth.port",
+    "PROTOCOL": "Transport.Eth.protocol",
+    "IPV6": "Transport.Eth.ipv6",
+    "TCP_NODELAY": "Transport.Eth.tcp_nodelay",
+    # Usb
+    "SERIAL_NUMBER": "Transport.Usb.serial_number",
+    "CONFIGURATION_NUMBER": "Transport.Usb.configuration_number",
+    "INTERFACE_NUMBER": "Transport.Usb.interface_number",
+    "COMMAND_ENDPOINT_NUMBER": "Transport.Usb.out_ep_number",
+    "REPLY_ENDPOINT_NUMBER": "Transport.Usb.in_ep_number",
+    "VENDOR_ID": "Transport.Usb.vendor_id",
+    "PRODUCT_ID": "Transport.Usb.product_id",
+    "LIBRARY": "Transport.Usb.library",
+    # Can
+    "CAN_DRIVER": "Transport.Can.interface",
+    "CHANNEL": "Transport.Can.channel",
+    "MAX_DLC_REQUIRED": "Transport.Can.max_dlc_required",
+    #   "MAX_CAN_FD_DLC": "Transport.Can.max_can_fd_dlc",
+    "PADDING_VALUE": "Transport.Can.padding_value",
+    "CAN_USE_DEFAULT_LISTENER": "Transport.Can.use_default_listener",
+    # Swap master and slave IDs. (s. https://github.com/christoph2/pyxcp/issues/130)
+    "CAN_ID_SLAVE": "Transport.Can.can_id_master",
+    "CAN_ID_MASTER": "Transport.Can.can_id_slave",
+    "CAN_ID_BROADCAST": "Transport.Can.can_id_broadcast",
+    "BITRATE": "Transport.Can.bitrate",
+    "RECEIVE_OWN_MESSAGES": "Transport.Can.receive_own_messages",
+    "POLL_INTERVAL": "Transport.Can.poll_interval",
+    "FD": "Transport.Can.fd",
+    "DATA_BITRATE": "Transport.Can.data_bitrate",
+    "ACCEPT_VIRTUAL": "Transport.Can.Kvaser.accept_virtual",
+    "SJW": "Transport.Can.sjw_abr",
+    "TSEG1": "Transport.Can.tseg1_abr",
+    "TSEG2": "Transport.Can.tseg2_abr",
+    "TTY_BAUDRATE": "Transport.Can.SlCan.ttyBaudrate",
+    "UNIQUE_HARDWARE_ID": "Transport.Can.Ixxat.unique_hardware_id",
+    "RX_FIFO_SIZE": "Transport.Can.Ixxat.rx_fifo_size",
+    "TX_FIFO_SIZE": "Transport.Can.Ixxat.tx_fifo_size",
+    "DRIVER_MODE": "Transport.Can.Kvaser.driver_mode",
+    "NO_SAMP": "Transport.Can.Kvaser.no_samp",
+    "SINGLE_HANDLE": "Transport.Can.Kvaser.single_handle",
+    "USE_SYSTEM_TIMESTAMP": "Transport.Can.Neovi.use_system_timestamp",
+    "OVERRIDE_LIBRARY_NAME": "Transport.Can.Neovi.override_library_name",
+    "BAUDRATE": "Transport.Can.Serial.baudrate",
+    "SLEEP_AFTER_OPEN": "Transport.Can.SlCan.sleep_after_open",
+    "DEVICE_NUMBER": "Transport.Can.Systec.device_number",
+    "RX_BUFFER_ENTRIES": "Transport.Can.Systec.rx_buffer_entries",
+    "TX_BUFFER_ENTRIES": "Transport.Can.Systec.tx_buffer_entries",
+    "FLAGS": "Transport.Can.Usb2Can.flags",
+    "APP_NAME": "Transport.Can.Vector.app_name",
+    "RX_QUEUE_SIZE": "Transport.Can.Vector.rx_queue_size",
+}
+
+
+def nested_dict_update(d: dict, key: str, value) -> None:
+    root, *path, key = key.split(".")
+    sub_dict = d[root]
+    for part in path:
+        if part not in sub_dict:
+            sub_dict[part] = defaultdict(dict)
+        sub_dict = sub_dict[part]
+    sub_dict[key] = value
+
+
+def convert_config(legacy_config: dict, logger: LoggingConfigurable) -> Config:
+    interface_name = None
+    resolv = []
+    d = defaultdict(dict)
+    for key, value in legacy_config.items():
+        key = key.upper()
+        item = LEGACY_KEYWORDS.get(key)
+        if item is None:
+            logger.warning(f"Unknown keyword {key!r} in config file")
+            continue
+        if key == "CAN_DRIVER":
+            value = value.lower()
+            interface_name = value
+        if key in ("SERIAL", "LOG_ERRORS", "STATE", "RTSCTS"):
+            resolv.append((key, value))
+        else:
+            nested_dict_update(d=d, key=item, value=value)
+    for key, value in resolv:
+        if key == "SERIAL":
+            if interface_name == "neovi":
+                d["Transport.Can.Neovi.serial"] = value
+            elif interface_name == "vector":
+                d["Transport.Can.Vector.serial"] = value
+        elif key == "LOG_ERRORS":
+            if interface_name == "nican":
+                d["Transport.Can.NiCan.log_errors"] = value
+        elif key == "STATE":
+            if interface_name == "pcan":
+                d["Transport.Can.PCan.state"] = value
+            elif interface_name == "systec":
+                d["Transport.Can.Systec.state"] = value
+        elif key == "RTSCTS":
+            if interface_name == "serial":
+                d["Transport.Can.Serial.rtscts"] = value
+            elif interface_name == "slcan":
+                d["Transport.Can.SlCan.rtscts"] = value
+    return Config(d)

pyxcp/constants.py

@@ -0,0 +1,47 @@
+#!/usr/bin/env python
+import struct
+from typing import Any, Callable
+
+
+PackerType = Callable[[int], bytes]
+UnpackerType = Callable[[bytes], tuple[Any, ...]]
+
+
+def makeBytePacker(byteorder: str = "@") -> PackerType:
+    """"""
+    return struct.Struct(f"{byteorder}B").pack
+
+
+def makeByteUnpacker(byteorder: str = "@") -> UnpackerType:
+    """"""
+    return struct.Struct(f"{byteorder}B").unpack
+
+
+def makeWordPacker(byteorder: str = "@") -> PackerType:
+    """"""
+    return struct.Struct(f"{byteorder}H").pack
+
+
+def makeWordUnpacker(byteorder: str = "@") -> UnpackerType:
+    """"""
+    return struct.Struct(f"{byteorder}H").unpack
+
+
+def makeDWordPacker(byteorder: str = "@") -> PackerType:
+    """"""
+    return struct.Struct(f"{byteorder}I").pack
+
+
+def makeDWordUnpacker(byteorder: str = "@") -> UnpackerType:
+    """"""
+    return struct.Struct(f"{byteorder}I").unpack
+
+
+def makeDLongPacker(byteorder: str = "@") -> PackerType:
+    """"""
+    return struct.Struct(f"{byteorder}Q").pack
+
+
+def makeDLongUnpacker(byteorder: str = "@") -> UnpackerType:
+    """"""
+    return struct.Struct(f"{byteorder}Q").unpack

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

@@ -0,0 +1,105 @@
+
+#if !defined(__BIN_HPP)
+    #define __BIN_HPP
+
+    #include <cstdint>
+    #include <iostream>
+    #include <map>
+    #include <optional>
+    #include <string>
+    #include <vector>
+
+    #include "mcobject.hpp"
+
+class Bin {
+   public:
+
+    Bin(std::uint16_t size) : m_size(size), m_residual_capacity(size) {
+    }
+
+    Bin(std::uint16_t size, uint16_t residual_capacity, const std::vector<McObject>& entries) :
+        m_size(size), m_residual_capacity(residual_capacity), m_entries(entries) {
+    }
+
+    void append(const McObject& bin) {
+        m_entries.emplace_back(bin);
+    }
+
+    void set_entries(std::vector<McObject>&& entries) {
+        m_entries = std::move(entries);
+    }
+
+    std::uint16_t get_size() const {
+        return m_size;
+    }
+
+    void set_size(const std::uint16_t size) {
+        m_size = size;
+    }
+
+    std::uint16_t get_residual_capacity() const {
+        return m_residual_capacity;
+    }
+
+    void set_residual_capacity(const std::uint16_t residual_capacity) {
+        m_residual_capacity = residual_capacity;
+    }
+
+    const std::vector<McObject>& get_entries() const {
+        return m_entries;
+    }
+
+    bool operator==(const Bin& other) const {
+        return (m_size == other.m_size) && (m_residual_capacity == other.m_residual_capacity) && (m_entries == other.m_entries);
+    }
+
+    std::string dumps() const {
+        std::stringstream ss;
+
+        ss << to_binary(m_size);
+        ss << to_binary(m_residual_capacity);
+
+        std::size_t entries_size = m_entries.size();
+        ss << to_binary(entries_size);
+        for (const auto& entry : m_entries) {
+            ss << entry.dumps();
+        }
+
+        return ss.str();
+    }
+
+   private:
+
+    std::uint16_t         m_size;
+    std::uint16_t         m_residual_capacity;
+    std::vector<McObject> m_entries{};
+};
+
+std::string bin_entries_to_string(const std::vector<McObject>& entries);
+
+std::string to_string(const Bin& obj) {
+    std::stringstream ss;
+    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 (std::size_t i = 0; i < entries.size(); ++i) {
+        ss << to_string(entries[i]);
+        if (i + 1 < entries.size()) {
+            ss << ", ";
+        }
+    }
+    return ss.str();
+}
+
+    #if 0
+
+    @property
+    def __len__(self) -> int:
+        return len(self.entries)
+    #endif
+
+#endif  // __BIN_HPP

pyxcp/cpp_ext/blockmem.hpp

@@ -0,0 +1,58 @@
+
+#ifndef __BLOCKMEM_HPP
+#define __BLOCKMEM_HPP
+
+#include <array>
+#include <cstdint>
+#include <mutex>
+
+/*
+ *
+ * Super simplicistic block memory manager.
+ *
+ */
+template<typename T, int _IS, int _NB>
+class BlockMemory {
+   public:
+
+    using mem_block_t = std::array<T, _IS>;
+
+    constexpr explicit BlockMemory() noexcept : m_memory{ nullptr }, m_allocation_count{ 0 } {
+        m_memory = new T[_IS * _NB];
+    }
+
+    ~BlockMemory() noexcept {
+        if (m_memory) {
+            delete[] m_memory;
+        }
+    }
+
+    BlockMemory(const BlockMemory&) = delete;
+
+    constexpr T* acquire() noexcept {
+        const std::scoped_lock lock(m_mtx);
+
+        if (m_allocation_count >= _NB) {
+            return nullptr;
+        }
+        T* ptr = reinterpret_cast<T*>(m_memory + (m_allocation_count * _IS));
+        m_allocation_count++;
+        return ptr;
+    }
+
+    constexpr void release() noexcept {
+        const std::scoped_lock lock(m_mtx);
+        if (m_allocation_count == 0) {
+            return;
+        }
+        m_allocation_count--;
+    }
+
+   private:
+
+    T*            m_memory;
+    std::uint32_t m_allocation_count;
+    std::mutex    m_mtx;
+};
+
+#endif  // __BLOCKMEM_HPP