pyxcp 0.25.2__cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl

pyxcp/recorder/wrap.cpp

@@ -0,0 +1,184 @@
+
+#include <pybind11/functional.h>
+#include <pybind11/numpy.h>
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+#include <memory>
+
+#include <cstdint>
+
+#include "rekorder.hpp"
+
+namespace py = pybind11;
+using namespace pybind11::literals;
+
+
+class PyDaqOnlinePolicy : public DaqOnlinePolicy {
+   public:
+
+    using DaqOnlinePolicy::DaqOnlinePolicy;
+
+    void on_daq_list(
+        std::uint16_t daq_list_num, std::uint64_t timestamp0, std::uint64_t timestamp1,
+        const std::vector<measurement_value_t>& measurement
+    ) override {
+        PYBIND11_OVERRIDE_PURE(void, DaqOnlinePolicy, on_daq_list, daq_list_num, timestamp0, timestamp1, measurement);
+    }
+
+    void initialize() override {
+        PYBIND11_OVERRIDE(void, DaqOnlinePolicy, initialize);
+    }
+
+    void finalize() override {
+        PYBIND11_OVERRIDE(void, DaqOnlinePolicy, finalize);
+    }
+};
+
+class PyDaqRecorderPolicy : public DaqRecorderPolicy {
+   public:
+
+    using DaqRecorderPolicy::DaqRecorderPolicy;
+
+    void initialize() override {
+        PYBIND11_OVERRIDE(void, DaqRecorderPolicy, initialize);
+    }
+
+    void finalize() override {
+        PYBIND11_OVERRIDE(void, DaqRecorderPolicy, finalize);
+    }
+};
+
+class PyXcpLogFileDecoder : public XcpLogFileDecoder {
+   public:
+
+    using XcpLogFileDecoder::XcpLogFileDecoder;
+
+    void on_daq_list(
+        std::uint16_t daq_list_num, std::uint64_t timestamp0, std::uint64_t timestamp1,
+        const std::vector<measurement_value_t>& measurement
+    ) override {
+        PYBIND11_OVERRIDE_PURE(void, XcpLogFileDecoder, on_daq_list, daq_list_num, timestamp0, timestamp1, measurement);
+    }
+
+    void initialize() override {
+        PYBIND11_OVERRIDE(void, XcpLogFileDecoder, initialize);
+    }
+
+    void finalize() override {
+        PYBIND11_OVERRIDE(void, XcpLogFileDecoder, finalize);
+    }
+};
+
+PYBIND11_MODULE(rekorder, m) {
+    m.doc() = "XCP raw frame recorder.";
+    m.def("data_types", get_data_types);
+
+    py::class_<FileHeaderType>(m, "FileHeaderType")
+        .def(py::init<std::uint16_t, std::uint16_t, std::uint16_t, std::uint32_t, std::uint32_t, std::uint32_t, std::uint32_t>())
+        .def("__repr__", [](const FileHeaderType& self) {
+            std::stringstream ss;
+            ss << "FileHeaderType(" << std::endl;
+            ss << "    hdr_size=" << self.hdr_size << "," << std::endl;
+            ss << "    version=" << self.version << "," << std::endl;
+            ss << "    options=" << self.options << "," << std::endl;
+            ss << "    num_containers=" << self.num_containers << "," << std::endl;
+            ss << "    record_count=" << self.record_count << "," << std::endl;
+            ss << "    size_compressed=" << self.size_compressed << "," << std::endl;
+            ss << "    size_uncompressed=" << self.size_uncompressed << "," << std::endl;
+            ss << "    compression_ratio="
+               << (double)((std::uint64_t)(((double)self.size_uncompressed / (double)self.size_compressed * 100.0) + 0.5)) / 100.0
+               << std::endl;
+            ss << ")" << std::endl;
+            return ss.str();
+        });
+
+    py::class_<Deserializer>(m, "Deserializer").def(py::init<const std::string&>()).def("run", &Deserializer::run);
+
+    py::class_<XcpLogFileReader>(m, "_PyXcpLogFileReader")
+        .def(py::init<const std::string&>())
+        .def("next_block", &XcpLogFileReader::next_block)
+        .def("reset", &XcpLogFileReader::reset)
+        .def("get_header_as_tuple", &XcpLogFileReader::get_header_as_tuple)
+        .def("get_metadata", [](const XcpLogFileReader& self) { return py::bytes(self.get_metadata()); });
+
+    py::class_<XcpLogFileWriter>(m, "_PyXcpLogFileWriter")
+        .def(
+            py::init<const std::string&, std::uint32_t, std::uint32_t, std::string_view>(), py::arg("filename"),
+            py::arg("prealloc"), py::arg("chunk_size"), py::arg("metadata") = ""
+        )
+        .def("finalize", &XcpLogFileWriter::finalize)
+        .def("add_frame", &XcpLogFileWriter::add_frame);
+
+    py::class_<MeasurementParameters>(m, "MeasurementParameters")
+        .def(py::init<
+             std::uint8_t, std::uint8_t, bool, bool, bool, bool, double, std::uint8_t, std::uint16_t, const TimestampInfo&,
+             const std::vector<std::shared_ptr<DaqListBase>>&, const std::vector<std::uint16_t>&>())
+        .def("dumps", [](const MeasurementParameters& self) { return py::bytes(self.dumps()); })
+        .def(
+            "__repr__",
+            [](const MeasurementParameters& self) {
+                std::stringstream ss;
+                ss << "MeasurementParameters(";
+                ss << "byte_order=\"" << byte_order_to_string(self.m_byte_order) << "\", ";
+                ss << "id_field_size=" << static_cast<std::uint16_t>(self.m_id_field_size) << ", ";
+                ss << "timestamps_supported=" << bool_to_string(self.m_timestamps_supported) << ", ";
+                ss << "ts_fixed=" << bool_to_string(self.m_ts_fixed) << ", ";
+                ss << "prescaler_supported=" << bool_to_string(self.m_prescaler_supported) << ", ";
+                ss << "selectable_timestamps=" << bool_to_string(self.m_selectable_timestamps) << ", ";
+                ss << "ts_scale_factor=" << self.m_ts_scale_factor << ", ";
+                ss << "ts_size=" << static_cast<std::uint16_t>(self.m_ts_size) << ", ";
+                ss << "min_daq=" << static_cast<std::uint16_t>(self.m_min_daq) << ", ";
+                ss << "timestamp_info=" << self.get_timestamp_info().to_string() << ", ";
+                ss << "daq_lists=[\n";
+                for (const auto& dl : self.m_daq_lists) {
+                    ss << dl->to_string() << ",\n";
+                }
+                ss << "],\n";
+                ss << "first_pids=[";
+                for (auto fp : self.m_first_pids) {
+                    ss << fp << ", ";
+                }
+                ss << "]";
+                return ss.str();
+            }
+        )
+        .def_property_readonly("byte_order", &MeasurementParameters::get_byte_order)
+        .def_property_readonly("id_field_size", &MeasurementParameters::get_id_field_size)
+        .def_property_readonly("timestamps_supported", &MeasurementParameters::get_timestamps_supported)
+        .def_property_readonly("ts_fixed", &MeasurementParameters::get_ts_fixed)
+        .def_property_readonly("prescaler_supported", &MeasurementParameters::get_prescaler_supported)
+        .def_property_readonly("selectable_timestamps", &MeasurementParameters::get_selectable_timestamps)
+        .def_property_readonly("ts_scale_factor", &MeasurementParameters::get_ts_scale_factor)
+        .def_property_readonly("ts_size", &MeasurementParameters::get_ts_size)
+        .def_property_readonly("min_daq", &MeasurementParameters::get_min_daq)
+        .def_property_readonly("timestamp_info", &MeasurementParameters::get_timestamp_info)
+        .def_property_readonly("daq_lists", &MeasurementParameters::get_daq_lists)
+        .def_property_readonly("first_pids", &MeasurementParameters::get_first_pids)
+        .def_property_readonly("timestamp_info", &MeasurementParameters::get_timestamp_info);
+
+    py::class_<DaqRecorderPolicy, PyDaqRecorderPolicy>(m, "DaqRecorderPolicy", py::dynamic_attr())
+        .def(py::init<>())
+        .def("create_writer", &DaqRecorderPolicy::create_writer)
+        .def("feed", &DaqRecorderPolicy::feed)
+        .def("set_parameters", &DaqRecorderPolicy::set_parameters)
+        .def("initialize", &DaqRecorderPolicy::initialize)
+        .def("finalize", &DaqRecorderPolicy::finalize);
+
+    py::class_<DaqOnlinePolicy, PyDaqOnlinePolicy>(m, "DaqOnlinePolicy", py::dynamic_attr())
+        .def(py::init<>())
+        .def("on_daq_list", &DaqOnlinePolicy::on_daq_list)
+        .def("feed", &DaqOnlinePolicy::feed)
+        .def("finalize", &DaqOnlinePolicy::finalize)
+        .def("set_parameters", &DaqOnlinePolicy::set_parameters)
+        .def("initialize", &DaqOnlinePolicy::initialize);
+
+    py::class_<XcpLogFileDecoder, PyXcpLogFileDecoder>(m, "XcpLogFileDecoder", py::dynamic_attr())
+        .def(py::init<const std::string&>())
+        .def("run", &XcpLogFileDecoder::run)
+        .def("on_daq_list", &XcpLogFileDecoder::on_daq_list)
+        .def_property_readonly("parameters", &XcpLogFileDecoder::get_parameters)
+        .def_property_readonly("daq_lists", &XcpLogFileDecoder::get_daq_lists)
+        .def("get_header", &XcpLogFileDecoder::get_header)
+        .def("initialize", &XcpLogFileDecoder::initialize)
+        .def("finalize", &XcpLogFileDecoder::finalize);
+}

pyxcp/recorder/writer.hpp

@@ -0,0 +1,302 @@
+
+#ifndef RECORDER_WRITER_HPP
+#define RECORDER_WRITER_HPP
+
+constexpr std::uint64_t MASK32 = (1ULL << 32) - 1;
+
+class XcpLogFileWriter {
+   public:
+
+    explicit XcpLogFileWriter(
+        const std::string &file_name, uint32_t prealloc = 10UL, uint32_t chunk_size = 1, std::string_view metadata = ""
+    ) {
+        if (!file_name.ends_with(detail::FILE_EXTENSION)) {
+            m_file_name = file_name + detail::FILE_EXTENSION;
+        } else {
+            m_file_name = file_name;
+        }
+        m_opened = false;
+
+#if defined(_WIN32)
+        m_fd = CreateFileA(
+            m_file_name.c_str(), GENERIC_READ | GENERIC_WRITE, 0, (LPSECURITY_ATTRIBUTES) nullptr, CREATE_ALWAYS,
+            FILE_ATTRIBUTE_NORMAL | FILE_FLAG_RANDOM_ACCESS, nullptr
+        );
+        if (m_fd == INVALID_HANDLE_VALUE) {
+            throw std::runtime_error(error_string("XcpLogFileWriter::CreateFileA", get_last_error()));
+        } else {
+            m_opened = true;
+        }
+#else
+        m_fd = open(m_file_name.c_str(), O_CREAT | O_RDWR | O_TRUNC, 0666);
+        if (m_fd == -1) {
+            throw std::runtime_error(error_string("XcpLogFileWriter::open", get_last_error()));
+        } else {
+            m_opened = true;
+        }
+#endif
+        m_hard_limit = megabytes(prealloc);
+        resize(m_hard_limit);
+        m_mmap                 = new mio::mmap_sink(m_fd);
+        m_chunk_size           = 512 * 1024;  // megabytes(chunk_size);
+        m_intermediate_storage = new blob_t[m_chunk_size + megabytes(1)];
+        m_offset               = detail::FILE_HEADER_SIZE + detail::MAGIC_SIZE;
+        m_metadata             = metadata;
+
+        if (!metadata.empty()) {
+            m_offset += std::size(metadata);
+            write_metadata();
+        }
+        start_thread();
+    }
+
+    ~XcpLogFileWriter() {
+        finalize();
+#ifdef __APPLE__
+        if (collector_thread.joinable()) {
+            collector_thread.join();
+        }
+#endif
+    }
+
+    void finalize() {
+        std::error_code ec;
+        if (!m_finalized) {
+            m_finalized = true;
+            stop_thread();
+
+            if (!m_opened) {
+                return;
+            }
+
+            if (m_container_record_count) {
+                compress_frames();
+            }
+
+            std::uint16_t options = m_metadata.empty() ? 0 : XMRAW_HAS_METADATA;
+
+            write_header(
+                detail::VERSION, options, m_num_containers, m_record_count, m_total_size_compressed, m_total_size_uncompressed
+            );
+            m_mmap->unmap();
+            ec = mio::detail::last_error();
+            if (ec.value() != 0) {
+                throw std::runtime_error(error_string("XcpLogFileWriter::mio::unmap", ec));
+            }
+
+            resize(m_offset);
+#if defined(_WIN32)
+            if (!CloseHandle(m_fd)) {
+                throw std::runtime_error(error_string("XcpLogFileWriter::CloseHandle", get_last_error()));
+            }
+#else
+            if (close(m_fd) == -1) {
+                throw std::runtime_error(error_string("XcpLogFileWriter::close", get_last_error()));
+            }
+#endif
+            delete m_mmap;
+            delete[] m_intermediate_storage;
+        }
+    }
+
+    void add_frame(uint8_t category, uint16_t counter, std::uint64_t timestamp, uint16_t length, char const *data) {
+        auto payload = new char[length];
+
+        _fcopy(payload, data, length);
+        my_queue.put(std::make_tuple(category, counter, timestamp, length, payload));
+    }
+
+   protected:
+
+    void resize(std::uint64_t size, bool remap = false) {
+        std::error_code ec;
+
+        if (remap) {
+            m_mmap->unmap();
+            ec = mio::detail::last_error();
+            if (ec.value() != 0) {
+                throw std::runtime_error(error_string("XcpLogFileWriter::mio::unmap", ec));
+            }
+        }
+
+#if defined(_WIN32)
+        LONG low_part  = (MASK32 & size);
+        LONG high_part = size >> 32;
+
+        if (SetFilePointer(m_fd, low_part, &high_part, FILE_BEGIN) == INVALID_SET_FILE_POINTER) {
+            auto err = get_last_error();
+
+            if (err.value() != NO_ERROR) {
+                throw std::runtime_error(error_string("XcpLogFileWriter::SetFilePointer", err));
+            }
+        }
+        if (SetEndOfFile(m_fd) == 0) {
+            throw std::runtime_error(error_string("XcpLogFileWriter::SetEndOfFile", get_last_error()));
+        }
+#else
+        if (ftruncate(m_fd, size) == -1) {
+            throw std::runtime_error(error_string("XcpLogFileWriter::ftruncate", get_last_error()));
+        }
+#endif
+        if (remap) {
+            m_mmap->map(m_fd, 0, size, ec);
+            if (ec.value() != 0) {
+                throw std::runtime_error(error_string("XcpLogFileWriter::mio::map", ec));
+            }
+        }
+    }
+
+    blob_t *ptr(std::uint64_t pos = 0) const {
+        return (blob_t *)(m_mmap->data() + pos);
+    }
+
+    template<typename T>
+    void store_im(T const *data, std::uint32_t length) {
+        _fcopy(
+            reinterpret_cast<char *>(m_intermediate_storage + m_intermediate_storage_offset), reinterpret_cast<char const *>(data),
+            length
+        );
+        m_intermediate_storage_offset += length;
+    }
+
+    void compress_frames() {
+        auto container = ContainerHeaderType{};
+        // printf("Compressing %u frames... [%d]\n", m_container_record_count, m_intermediate_storage_offset);
+        const int cp_size = ::LZ4_compress_HC(
+            reinterpret_cast<char const *>(m_intermediate_storage),
+            reinterpret_cast<char *>(ptr(m_offset + detail::CONTAINER_SIZE)), m_intermediate_storage_offset,
+            LZ4_COMPRESSBOUND(m_intermediate_storage_offset), LZ4HC_CLEVEL_MAX
+        );
+
+        if (cp_size < 0) {
+            throw std::runtime_error("XcpLogFileWriter - LZ4 compression failed.");
+        }
+
+        if (m_offset > (m_hard_limit >> 1)) {
+            std::cout << "[INFO] " << current_timestamp() << ": Doubling measurement file size." << std::endl;
+            m_hard_limit <<= 1;
+            resize(m_hard_limit, true);
+            write_header(
+                detail::VERSION, m_metadata.empty() ? 0 : XMRAW_HAS_METADATA, m_num_containers, m_record_count,
+                m_total_size_compressed, m_total_size_uncompressed
+            );
+        }
+        container.record_count      = m_container_record_count;
+        container.size_compressed   = cp_size;
+        container.size_uncompressed = m_container_size_uncompressed;
+
+        _fcopy(reinterpret_cast<char *>(ptr(m_offset)), reinterpret_cast<char const *>(&container), detail::CONTAINER_SIZE);
+
+        m_offset += (detail::CONTAINER_SIZE + cp_size);
+        m_total_size_uncompressed += m_container_size_uncompressed;
+        m_total_size_compressed += cp_size;
+        m_record_count += m_container_record_count;
+        m_container_size_uncompressed = 0;
+        m_container_size_compressed   = 0;
+        m_container_record_count      = 0;
+        m_intermediate_storage_offset = 0;
+        m_num_containers += 1;
+    }
+
+    void write_bytes(std::uint64_t pos, std::uint64_t count, char const *buf) const {
+        auto addr = reinterpret_cast<char *>(ptr(pos));
+
+        _fcopy(addr, buf, count);
+    }
+
+    void write_header(
+        std::uint16_t version, std::uint16_t options, std::uint64_t num_containers, std::uint64_t record_count,
+        std::uint64_t size_compressed, std::uint64_t size_uncompressed
+    ) {
+        auto header = FileHeaderType{};
+        write_bytes(0x00000000UL, detail::MAGIC_SIZE, detail::MAGIC.c_str());
+        header.hdr_size          = detail::FILE_HEADER_SIZE + detail::MAGIC_SIZE;
+        header.version           = version;
+        header.options           = options;
+        header.num_containers    = num_containers;
+        header.record_count      = record_count;
+        header.size_compressed   = size_compressed;
+        header.size_uncompressed = size_uncompressed;
+        write_bytes(0x00000000UL + detail::MAGIC_SIZE, detail::FILE_HEADER_SIZE, reinterpret_cast<char const *>(&header));
+    }
+
+    void write_metadata() {
+        if (!m_metadata.empty()) {
+            write_bytes(detail::MAGIC_SIZE + detail::FILE_HEADER_SIZE, m_metadata.size(), m_metadata.c_str());
+        }
+    }
+
+    bool start_thread() {
+        if (collector_thread.joinable()) {
+            return false;
+        }
+        stop_collector_thread_flag = false;
+#ifdef __APPLE__
+        collector_thread = std::thread([this]() {
+#else
+        collector_thread = std::jthread([this]() {
+#endif
+            while (!stop_collector_thread_flag) {
+                auto       item    = my_queue.get();
+                const auto content = item.get();
+                if (stop_collector_thread_flag == true) {
+                    break;
+                }
+                const auto [category, counter, timestamp, length, payload] = *content;
+                const frame_header_t frame{ category, counter, timestamp, length };
+                store_im(&frame, sizeof(frame));
+                store_im(payload, length);
+                delete[] payload;
+                m_container_record_count += 1;
+                m_container_size_uncompressed += (sizeof(frame) + length);
+                if (m_container_size_uncompressed > m_chunk_size) {
+                    compress_frames();
+                }
+            }
+        });
+
+        return true;
+    }
+
+    bool stop_thread() {
+        if (!collector_thread.joinable()) {
+            return false;
+        }
+        stop_collector_thread_flag = true;
+        my_queue.put(FrameTupleWriter{});  // Put something into the queue, otherwise the thread will hang forever.
+        collector_thread.join();
+        return true;
+    }
+
+   private:
+
+    std::string           m_file_name;
+    std::uint64_t         m_offset{ 0 };
+    std::uint32_t         m_chunk_size{ 0 };
+    std::string           m_metadata;
+    bool                  m_opened{ false };
+    std::uint64_t         m_num_containers{ 0 };
+    std::uint64_t         m_record_count{ 0UL };
+    std::uint32_t         m_container_record_count{ 0UL };
+    std::uint64_t         m_total_size_uncompressed{ 0UL };
+    std::uint64_t         m_total_size_compressed{ 0UL };
+    std::uint32_t         m_container_size_uncompressed{ 0UL };
+    std::uint32_t         m_container_size_compressed{ 0UL };
+    __ALIGN blob_t       *m_intermediate_storage{ nullptr };
+    std::uint32_t         m_intermediate_storage_offset{ 0 };
+    std::uint64_t         m_hard_limit{ 0 };
+    mio::file_handle_type m_fd{ INVALID_HANDLE_VALUE };
+    mio::mmap_sink       *m_mmap{ nullptr };
+    bool                  m_finalized{ false };
+#ifdef __APPLE__
+    std::thread collector_thread{};
+#else
+    std::jthread collector_thread{};
+#endif
+    std::mutex                             mtx;
+    TsQueue<FrameTupleWriter>              my_queue;
+    BlockMemory<char, XCP_PAYLOAD_MAX, 16> mem{};
+    std::atomic_bool                       stop_collector_thread_flag{ false };
+};
+
+#endif  // RECORDER_WRITER_HPP

pyxcp/scripts/pyxcp_probe_can_drivers.py

@@ -0,0 +1,20 @@
+#!/usr/bin/env python
+
+import can
+
+
+def main():
+    can.log.setLevel("ERROR")
+    interfaces = can.detect_available_configs()
+    print("-" * 80)
+    if not interfaces:
+        print("No CAN-interfaces installed on your system.")
+    else:
+        print("\nInstalled CAN-interfaces on your system:\n")
+        interfaces = sorted(interfaces, key=lambda e: e["interface"])
+        for interface in interfaces:
+            print("\t{:20s} -- CHANNEL: {}".format(interface["interface"], interface["channel"]))
+
+
+if __name__ == "__main__":
+    main()

pyxcp/scripts/xcp_examples.py

@@ -0,0 +1,64 @@
+#!/usr/bin/env python
+
+"""
+Copy pyXCP examples to a given directory.
+"""
+
+import argparse
+import sys
+from pathlib import Path
+
+from pyxcp import console
+
+
+pyver = sys.version_info
+if pyver.major == 3 and pyver.minor <= 9:
+    import pkg_resources
+
+    def copy_files_from_package(package_name: str, source_directory: str, args: argparse.Namespace) -> None:
+        destination_directory = args.output_directory
+        force = args.force
+        for fn in pkg_resources.resource_listdir(package_name, source_directory):
+            source_file = Path(pkg_resources.resource_filename(package_name, f"{source_directory}/{fn}"))
+            if source_file.suffix == ".py":
+                dest_file = Path(destination_directory) / fn
+                if dest_file.exists() and not force:
+                    console.print(f"[white]Destination file [blue]{fn!r} [white]already exists. Skipping.")
+                    continue
+                console.print(f"[blue]{source_file} [white]==> [green]{dest_file}")
+                data = source_file.read_text(encoding="utf-8")
+                dest_file.parent.mkdir(parents=True, exist_ok=True)
+                dest_file.write_text(data, encoding="utf-8")
+
+else:
+    import importlib.resources
+
+    def copy_files_from_package(package_name: str, source_directory: str, args: argparse.Namespace) -> None:
+        destination_directory = args.output_directory
+        force = args.force
+        for fn in importlib.resources.files(f"{package_name}.{source_directory}").iterdir():
+            if fn.suffix == ".py":
+                data = fn.read_text(encoding="utf-8")
+                dest_file = Path(destination_directory) / fn.name
+                if dest_file.exists() and not force:
+                    console.print(f"[white]Destination file [blue]{fn.name!r} [white]already exists. Skipping.")
+                    continue
+                console.print(f"[blue]{fn} [white]==> [green]{dest_file}")
+                dest_file.parent.mkdir(parents=True, exist_ok=True)
+                dest_file.write_text(data, encoding="utf-8")
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+
+    parser.add_argument("output_directory", metavar="output_directory", type=Path, help="output directory")
+
+    parser.add_argument("-f", "--force", action="store_true", help="overwrite existing files.")
+
+    args = parser.parse_args()
+    print("Copying pyXCP examples...\n")
+    copy_files_from_package("pyxcp", "examples", args)
+
+
+if __name__ == "__main__":
+    main()

pyxcp/scripts/xcp_fetch_a2l.py

@@ -0,0 +1,40 @@
+#!/usr/bin/env python
+"""Fetch A2L file from XCP slave (if supported)."""
+
+import sys
+from pathlib import Path
+
+from rich.prompt import Confirm
+
+from pyxcp.cmdline import ArgumentParser
+from pyxcp.types import XcpGetIdType
+
+
+def main():
+    ap = ArgumentParser(description="Fetch A2L file from XCP slave.")
+
+    with ap.run() as x:
+        x.connect()
+
+        # TODO: error-handling.
+        file_name = x.identifier(XcpGetIdType.FILENAME)
+        content = x.identifier(XcpGetIdType.FILE_TO_UPLOAD)
+        x.disconnect()
+        if not content:
+            sys.exit(f"Empty response from ID '{XcpGetIdType.FILE_TO_UPLOAD!r}'.")
+        if not file_name:
+            file_name = "output.a2l"
+        if not file_name.lower().endswith(".a2l"):
+            file_name += ".a2l"
+        dest = Path(file_name)
+        if dest.exists():
+            if not Confirm.ask(f"Destination file [green]{dest.name!r}[/green] already exists. Do you want to overwrite it?"):
+                print("Aborting...")
+                exit(1)
+        with dest.open("wt", encoding="utf-8") as of:
+            of.write(content)
+        print(f"A2L data written to {file_name!r}.")
+
+
+if __name__ == "__main__":
+    main()

pyxcp/scripts/xcp_id_scanner.py

@@ -0,0 +1,18 @@
+#!/usr/bin/env python
+"""Scan for available IDs."""
+
+from pyxcp.cmdline import ArgumentParser
+
+
+def main():
+    ap = ArgumentParser(description="Scan for available IDs.")
+    with ap.run() as x:
+        x.connect()
+        result = x.id_scanner()
+        for key, value in result.items():
+            print(f"{key}: {value}", end="\n\n")
+        x.disconnect()
+
+
+if __name__ == "__main__":
+    main()