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

pyxcp/recorder/.idea/.gitignore

@@ -0,0 +1,8 @@
+# Default ignored files
+/shelf/
+/workspace.xml
+# Editor-based HTTP Client requests
+/httpRequests/
+# Datasource local storage ignored files
+/dataSources/
+/dataSources.local.xml

pyxcp/recorder/.idea/misc.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="CMakeWorkspace" PROJECT_DIR="$PROJECT_DIR$" />
+</project>

pyxcp/recorder/.idea/modules.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/.idea/recorder.iml" filepath="$PROJECT_DIR$/.idea/recorder.iml" />
+    </modules>
+  </component>
+</project>

pyxcp/recorder/.idea/recorder.iml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module classpath="CMake" type="CPP_MODULE" version="4">
+  <component name="SonarLintModuleSettings">
+    <option name="uniqueId" value="ce2142a1-5ccc-4675-8d23-c6ee960ba851" />
+  </component>
+</module>

pyxcp/recorder/.idea/sonarlint/issuestore/3/8/3808afc69ac1edb9d760000a2f137335b1b99728

@@ -0,0 +1,7 @@
+
+T	cpp:S5028"8Replace this macro by "const", "constexpr" or an "enum".(����8�󓀹1
+	cpp:S3806""^non-portable path to file '<windows.h>'; specified path differs in case from file name on disk(��������
8�����1
+Tcpp:S954�
"8Move these 3 #include directives to the top of the file.(���8ﴔ��1
+T	cpp:S5028"8Replace this macro by "const", "constexpr" or an "enum".(����8帔��1
+	cpp:S3806""^non-portable path to file '<windows.h>'; specified path differs in case from file name on disk(��������
8�Ӕ��1
+Tcpp:S954�
"8Move these 3 #include directives to the top of the file.(���8�Ԕ��1

pyxcp/recorder/.idea/sonarlint/issuestore/index.pb

@@ -0,0 +1,7 @@
+
+>
+CMakeLists.txt,9\a\9a2aa4db38d3115ed60da621e012c0efc0172aae
+8
+wrap.cpp,b\4\b49006702b459496a8e8c94ebe60947108361b91
+<
+rekorder.hpp,3\8\3808afc69ac1edb9d760000a2f137335b1b99728

pyxcp/recorder/.idea/sonarlint/securityhotspotstore/index.pb

@@ -0,0 +1,7 @@
+
+>
+CMakeLists.txt,9\a\9a2aa4db38d3115ed60da621e012c0efc0172aae
+8
+wrap.cpp,b\4\b49006702b459496a8e8c94ebe60947108361b91
+<
+rekorder.hpp,3\8\3808afc69ac1edb9d760000a2f137335b1b99728

pyxcp/recorder/.idea/vcs.xml

@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="$PROJECT_DIR$/../.." vcs="Git" />
+    <mapping directory="$PROJECT_DIR$/lz4" vcs="Git" />
+    <mapping directory="$PROJECT_DIR$/mio" vcs="Git" />
+    <mapping directory="$PROJECT_DIR$/simde" vcs="Git" />
+    <mapping directory="$PROJECT_DIR$/simdjson" vcs="Git" />
+  </component>
+</project>

pyxcp/recorder/__init__.py

@@ -1,98 +1,96 @@
-#!/usr/bin/env python
-"""XCP Frame Recording Facility.
-"""
-
-from dataclasses import dataclass
-from typing import Union
-
-from pyxcp.types import FrameCategory
-
-
-try:
-    import pandas as pd
-except ImportError:
-    HAS_PANDAS = False
-else:
-    HAS_PANDAS = True
-
-from pyxcp.recorder.rekorder import DaqOnlinePolicy  # noqa: F401
-from pyxcp.recorder.rekorder import DaqRecorderPolicy  # noqa: F401
-from pyxcp.recorder.rekorder import Deserializer  # noqa: F401
-from pyxcp.recorder.rekorder import MeasurementParameters  # noqa: F401
-from pyxcp.recorder.rekorder import XcpLogFileDecoder as _XcpLogFileDecoder
-from pyxcp.recorder.rekorder import _PyXcpLogFileReader, _PyXcpLogFileWriter, data_types
-
-
-DATA_TYPES = data_types()
-
-
-@dataclass
-class XcpLogFileHeader:
-    """ """
-
-    version: int
-    options: int
-    num_containers: int
-    record_count: int
-    size_uncompressed: int
-    size_compressed: int
-    compression_ratio: float
-
-
-COUNTER_MAX = 0xFFFF
-
-
-class XcpLogFileReader:
-    """ """
-
-    def __init__(self, file_name):
-        self._reader = _PyXcpLogFileReader(file_name)
-
-    @property
-    def header(self):
-        return self._reader.get_header()
-
-    def get_header(self):
-        return XcpLogFileHeader(*self._reader.get_header_as_tuple())
-
-    def get_metadata(self):
-        return self._reader.get_metadata()
-
-    def __iter__(self):
-        while True:
-            frames = self._reader.next_block()
-            if frames is None:
-                break
-            for category, counter, timestamp, _, payload in frames:
-                yield (FrameCategory(category), counter, timestamp, payload)
-
-    def reset_iter(self):
-        self._reader.reset()
-
-    def as_dataframe(self):
-        if HAS_PANDAS:
-            df = pd.DataFrame((f for f in self), columns=["category", "counter", "timestamp", "payload"])
-            df = df.set_index("timestamp")
-            df.counter = df.counter.astype("uint16")
-            df.category = df.category.map({v: k for k, v in FrameCategory.__members__.items()}).astype("category")
-            return df
-        else:
-            raise NotImplementedError("method as_dataframe() requires 'pandas' package")
-
-
-class XcpLogFileWriter:
-    """ """
-
-    def __init__(self, file_name: str, prealloc=500, chunk_size=1):
-        self._writer = _PyXcpLogFileWriter(file_name, prealloc, chunk_size)
-        self._finalized = False
-
-    def __del__(self):
-        if not self._finalized:
-            self.finalize()
-
-    def add_frame(self, category: FrameCategory, counter: int, timestamp: float, payload: Union[bytes, bytearray]):
-        self._writer.add_frame(category, counter % (COUNTER_MAX + 1), timestamp, len(payload), payload)
-
-    def finalize(self):
-        self._writer.finalize()
+#!/usr/bin/env python
+"""XCP Frame Recording Facility."""
+
+from dataclasses import dataclass
+from typing import Union
+
+from pyxcp.transport.base import FrameCategory
+
+
+try:
+    import pandas as pd
+except ImportError:
+    HAS_PANDAS = False
+else:
+    HAS_PANDAS = True
+
+from pyxcp.recorder.rekorder import DaqOnlinePolicy  # noqa: F401
+from pyxcp.recorder.rekorder import DaqRecorderPolicy  # noqa: F401
+from pyxcp.recorder.rekorder import Deserializer  # noqa: F401
+from pyxcp.recorder.rekorder import MeasurementParameters  # noqa: F401
+from pyxcp.recorder.rekorder import _PyXcpLogFileReader, _PyXcpLogFileWriter, data_types
+
+
+DATA_TYPES = data_types()
+
+
+@dataclass
+class XcpLogFileHeader:
+    """ """
+
+    version: int
+    options: int
+    num_containers: int
+    record_count: int
+    size_uncompressed: int
+    size_compressed: int
+    compression_ratio: float
+
+
+COUNTER_MAX = 0xFFFF
+
+
+class XcpLogFileReader:
+    """ """
+
+    def __init__(self, file_name):
+        self._reader = _PyXcpLogFileReader(file_name)
+
+    @property
+    def header(self):
+        return self._reader.get_header()
+
+    def get_header(self):
+        return XcpLogFileHeader(*self._reader.get_header_as_tuple())
+
+    def get_metadata(self):
+        return self._reader.get_metadata()
+
+    def __iter__(self):
+        while True:
+            frames = self._reader.next_block()
+            if frames is None:
+                break
+            for category, counter, timestamp, _, payload in frames:
+                yield (FrameCategory(category), counter, timestamp, payload)
+
+    def reset_iter(self):
+        self._reader.reset()
+
+    def as_dataframe(self):
+        if HAS_PANDAS:
+            df = pd.DataFrame((f for f in self), columns=["category", "counter", "timestamp", "payload"])
+            df = df.set_index("timestamp")
+            df.counter = df.counter.astype("uint16")
+            df.category = df.category.map({v: k for k, v in FrameCategory.__members__.items()}).astype("category")
+            return df
+        else:
+            raise NotImplementedError("method as_dataframe() requires 'pandas' package")
+
+
+class XcpLogFileWriter:
+    """ """
+
+    def __init__(self, file_name: str, prealloc=500, chunk_size=1):
+        self._writer = _PyXcpLogFileWriter(file_name, prealloc, chunk_size)
+        self._finalized = False
+
+    def __del__(self):
+        if not self._finalized:
+            self.finalize()
+
+    def add_frame(self, category: FrameCategory, counter: int, timestamp: float, payload: Union[bytes, bytearray]):
+        self._writer.add_frame(category, counter % (COUNTER_MAX + 1), timestamp, len(payload), payload)
+
+    def finalize(self):
+        self._writer.finalize()

pyxcp/recorder/converter/__init__.py

@@ -1,5 +1,6 @@
 """Convert pyXCPs .xmraw files to common data formats."""
 
+from contextlib import suppress
 import csv
 import logging
 import os
@@ -119,10 +120,8 @@ class XcpLogFileDecoder(_XcpLogFileDecoder):
         self.out_file_suffix = out_file_suffix
         self.target_type_map = target_type_map or {}
         if remove_file:
-            try:
+            with suppress(FileNotFoundError):
                 os.unlink(self.out_file_name)
-            except FileNotFoundError:
-                pass
 
     def initialize(self) -> None:
         self.on_initialize()
@@ -154,7 +153,6 @@ class XcpLogFileDecoder(_XcpLogFileDecoder):
 
 
 class CollectRows:
-
     def on_daq_list(self, daq_list_num: int, timestamp0: int, timestamp1: int, measurements: list) -> None:
         storage_container = self.tables[daq_list_num]
         storage_container.timestamp0.append(timestamp0)
@@ -214,7 +212,6 @@ class ArrowConverter(CollectRows, XcpLogFileDecoder):
 
 
 class CsvConverter(XcpLogFileDecoder):
-
     def __init__(self, recording_file_name: str, target_file_name: str = ""):
         super().__init__(
             recording_file_name=recording_file_name, out_file_suffix=".csv", remove_file=False, target_file_name=target_file_name
@@ -242,7 +239,6 @@ class CsvConverter(XcpLogFileDecoder):
 
 
 class ExcelConverter(XcpLogFileDecoder):
-
     def __init__(self, recording_file_name: str, target_file_name: str = ""):
         super().__init__(recording_file_name=recording_file_name, out_file_suffix=".xlsx", target_file_name=target_file_name)
 
@@ -273,7 +269,6 @@ class ExcelConverter(XcpLogFileDecoder):
 
 
 class HdfConverter(CollectRows, XcpLogFileDecoder):
-
     def __init__(self, recording_file_name: str, target_file_name: str = ""):
         super().__init__(recording_file_name=recording_file_name, out_file_suffix=".h5", target_file_name=target_file_name)
 
@@ -296,7 +291,6 @@ class HdfConverter(CollectRows, XcpLogFileDecoder):
 
 
 class MdfConverter(CollectRows, XcpLogFileDecoder):
-
     def __init__(self, recording_file_name: str, target_file_name: str = ""):
         super().__init__(
             recording_file_name=recording_file_name,
@@ -367,8 +361,8 @@ class SqliteConverter(XcpLogFileDecoder):
         self.create_table(sc)
         self.logger.info(f"Creating table {sc.name!r}.")
         self.insert_stmt[sc.name] = (
-            f"""INSERT INTO {sc.name}({', '.join(['timestamp0', 'timestamp1'] + [r.name for r in sc.arr])})"""
-            f""" VALUES({', '.join(["?" for _ in range(len(sc.arr) + 2)])})"""
+            f"""INSERT INTO {sc.name}({", ".join(["timestamp0", "timestamp1"] + [r.name for r in sc.arr])})"""
+            f""" VALUES({", ".join(["?" for _ in range(len(sc.arr) + 2)])})"""
         )
 
     def on_finalize(self) -> None:

pyxcp/recorder/reader.hpp

@@ -1,139 +1,138 @@
-
-#ifndef RECORDER_READER_HPP
-#define RECORDER_READER_HPP
-
-#include <iostream>
-
-class XcpLogFileReader {
-   public:
-
-    explicit XcpLogFileReader(const std::string &file_name) {
-        if (!file_name.ends_with(detail::FILE_EXTENSION)) {
-            m_file_name = file_name + detail::FILE_EXTENSION;
-        } else {
-            m_file_name = file_name;
-        }
-
-        m_mmap = new mio::mmap_source(m_file_name);
-        blob_t magic[detail::MAGIC_SIZE + 1];
-
-        read_bytes(0UL, detail::MAGIC_SIZE, magic);
-        if (memcmp(detail::MAGIC.c_str(), magic, detail::MAGIC_SIZE) != 0) {
-            throw std::runtime_error("Invalid file magic.");
-        }
-        m_offset = detail::MAGIC_SIZE;
-
-        read_bytes(m_offset, detail::FILE_HEADER_SIZE, reinterpret_cast<blob_t *>(&m_header));
-        // printf("Sizes: %u %u %.3f\n", m_header.size_uncompressed,
-        //        m_header.size_compressed,
-        //        float(m_header.size_uncompressed) / float(m_header.size_compressed));
-        if (m_header.hdr_size != detail::FILE_HEADER_SIZE + detail::MAGIC_SIZE) {
-            throw std::runtime_error("File header size does not match.");
-        }
-        if (detail::VERSION != m_header.version) {
-            throw std::runtime_error("File version mismatch.");
-        }
-#if 0
-        if (m_header.num_containers < 1) {
-            throw std::runtime_error("At least one container required.");
-        }
-#endif
-        m_offset += detail::FILE_HEADER_SIZE;
-
-        if ((m_header.options & XMRAW_HAS_METADATA) == XMRAW_HAS_METADATA) {
-            std::size_t metadata_length = 0;
-            std::size_t data_start      = m_offset + sizeof(std::size_t);
-
-            read_bytes(m_offset, sizeof(std::size_t), reinterpret_cast<blob_t *>(&metadata_length));
-
-            std::copy(ptr(data_start), ptr(data_start + metadata_length), std::back_inserter(m_metadata));
-            // std::cout << "Metadata: " << m_metadata << std::endl;
-            m_offset += (metadata_length + sizeof(std::size_t));
-        }
-    }
-
-    [[nodiscard]] FileHeaderType get_header() const noexcept {
-        return m_header;
-    }
-
-    [[nodiscard]] auto get_header_as_tuple() const noexcept -> HeaderTuple {
-        auto hdr = get_header();
-
-        return std::make_tuple(
-            hdr.version, hdr.options, hdr.num_containers, hdr.record_count, hdr.size_uncompressed, hdr.size_compressed,
-            (double)((std::uint64_t)(((double)hdr.size_uncompressed / (double)hdr.size_compressed * 100.0) + 0.5)) / 100.0
-        );
-    }
-
-    [[nodiscard]] auto get_metadata() const noexcept {
-        return m_metadata;
-    }
-
-    void reset() noexcept {
-        m_current_container = 0;
-        m_offset            = file_header_size();
-    }
-
-    std::optional<FrameVector> next_block() {
-        auto          container = ContainerHeaderType{};
-        auto          frame     = frame_header_t{};
-        std::uint64_t boffs     = 0;
-        auto          result    = FrameVector{};
-        payload_t     payload;
-
-        if (m_current_container >= m_header.num_containers) {
-            return std::nullopt;
-        }
-        read_bytes(m_offset, detail::CONTAINER_SIZE, reinterpret_cast<blob_t *>(&container));
-        __ALIGN auto buffer = new blob_t[container.size_uncompressed];
-        m_offset += detail::CONTAINER_SIZE;
-        result.reserve(container.record_count);
-        const int uc_size = ::LZ4_decompress_safe(
-            reinterpret_cast<char const *>(ptr(m_offset)), reinterpret_cast<char *>(buffer), container.size_compressed,
-            container.size_uncompressed
-        );
-        if (uc_size < 0) {
-            throw std::runtime_error("LZ4 decompression failed.");
-        }
-        boffs = 0;
-        for (std::uint64_t idx = 0; idx < container.record_count; ++idx) {
-            _fcopy(reinterpret_cast<char *>(&frame), reinterpret_cast<char const *>(&(buffer[boffs])), sizeof(frame_header_t));
-            boffs += sizeof(frame_header_t);
-            result.emplace_back(
-                frame.category, frame.counter, frame.timestamp, frame.length, create_payload(frame.length, &buffer[boffs])
-            );
-            boffs += frame.length;
-        }
-        m_offset += container.size_compressed;
-        m_current_container += 1;
-        delete[] buffer;
-
-        return std::optional<FrameVector>{ result };
-    }
-
-    ~XcpLogFileReader() noexcept {
-        delete m_mmap;
-    }
-
-   protected:
-
-    [[nodiscard]] blob_t const *ptr(std::uint64_t pos = 0) const {
-        return reinterpret_cast<blob_t const *>(m_mmap->data() + pos);
-    }
-
-    void read_bytes(std::uint64_t pos, std::uint64_t count, blob_t *buf) const {
-        auto addr = reinterpret_cast<char const *>(ptr(pos));
-        _fcopy(reinterpret_cast<char *>(buf), addr, count);
-    }
-
-   private:
-
-    std::string       m_file_name;
-    std::uint64_t     m_offset{ 0 };
-    std::uint64_t     m_current_container{ 0 };
-    mio::mmap_source *m_mmap{ nullptr };
-    FileHeaderType    m_header;
-    std::string       m_metadata;
-};
-
-#endif  // RECORDER_READER_HPP
+
+#ifndef RECORDER_READER_HPP
+#define RECORDER_READER_HPP
+
+#include <iostream>
+
+class XcpLogFileReader {
+   public:
+
+    explicit XcpLogFileReader(const std::string &file_name) {
+        if (!file_name.ends_with(detail::FILE_EXTENSION)) {
+            m_file_name = file_name + detail::FILE_EXTENSION;
+        } else {
+            m_file_name = file_name;
+        }
+
+        m_mmap = new mio::mmap_source(m_file_name);
+        blob_t magic[detail::MAGIC_SIZE + 1];
+
+        read_bytes(0UL, detail::MAGIC_SIZE, magic);
+        if (memcmp(detail::MAGIC.c_str(), magic, detail::MAGIC_SIZE) != 0) {
+            throw std::runtime_error("Invalid file magic.");
+        }
+        m_offset = detail::MAGIC_SIZE;
+
+        read_bytes(m_offset, detail::FILE_HEADER_SIZE, reinterpret_cast<blob_t *>(&m_header));
+        // printf("Sizes: %u %u %.3f\n", m_header.size_uncompressed,
+        //        m_header.size_compressed,
+        //        float(m_header.size_uncompressed) / float(m_header.size_compressed));
+        if (m_header.hdr_size != detail::FILE_HEADER_SIZE + detail::MAGIC_SIZE) {
+            throw std::runtime_error("File header size does not match.");
+        }
+        if (detail::VERSION != m_header.version) {
+            throw std::runtime_error("File version mismatch.");
+        }
+#if 0
+        if (m_header.num_containers < 1) {
+            throw std::runtime_error("At least one container required.");
+        }
+#endif
+        m_offset += detail::FILE_HEADER_SIZE;
+
+        if ((m_header.options & XMRAW_HAS_METADATA) == XMRAW_HAS_METADATA) {
+            std::size_t metadata_length = 0;
+            std::size_t data_start      = m_offset + sizeof(std::size_t);
+
+            read_bytes(m_offset, sizeof(std::size_t), reinterpret_cast<blob_t *>(&metadata_length));
+
+            std::copy(ptr(data_start), ptr(data_start + metadata_length), std::back_inserter(m_metadata));
+            m_offset += (metadata_length + sizeof(std::size_t));
+        }
+    }
+
+    [[nodiscard]] FileHeaderType get_header() const noexcept {
+        return m_header;
+    }
+
+    [[nodiscard]] auto get_header_as_tuple() const noexcept -> HeaderTuple {
+        auto hdr = get_header();
+
+        return std::make_tuple(
+            hdr.version, hdr.options, hdr.num_containers, hdr.record_count, hdr.size_uncompressed, hdr.size_compressed,
+            (double)((std::uint64_t)(((double)hdr.size_uncompressed / (double)hdr.size_compressed * 100.0) + 0.5)) / 100.0
+        );
+    }
+
+    [[nodiscard]] auto get_metadata() const noexcept {
+        return m_metadata;
+    }
+
+    void reset() noexcept {
+        m_current_container = 0;
+        m_offset            = file_header_size();
+    }
+
+    std::optional<FrameVector> next_block() {
+        auto          container = ContainerHeaderType{};
+        auto          frame     = frame_header_t{};
+        std::uint64_t boffs     = 0;
+        auto          result    = FrameVector{};
+        payload_t     payload;
+
+        if (m_current_container >= m_header.num_containers) {
+            return std::nullopt;
+        }
+        read_bytes(m_offset, detail::CONTAINER_SIZE, reinterpret_cast<blob_t *>(&container));
+        __ALIGN auto buffer = new blob_t[container.size_uncompressed];
+        m_offset += detail::CONTAINER_SIZE;
+        result.reserve(container.record_count);
+        const int uc_size = ::LZ4_decompress_safe(
+            reinterpret_cast<char const *>(ptr(m_offset)), reinterpret_cast<char *>(buffer), container.size_compressed,
+            container.size_uncompressed
+        );
+        if (uc_size < 0) {
+            throw std::runtime_error("LZ4 decompression failed.");
+        }
+        boffs = 0;
+        for (std::uint64_t idx = 0; idx < container.record_count; ++idx) {
+            _fcopy(reinterpret_cast<char *>(&frame), reinterpret_cast<char const *>(&(buffer[boffs])), sizeof(frame_header_t));
+            boffs += sizeof(frame_header_t);
+            result.emplace_back(
+                frame.category, frame.counter, frame.timestamp, frame.length, create_payload(frame.length, &buffer[boffs])
+            );
+            boffs += frame.length;
+        }
+        m_offset += container.size_compressed;
+        m_current_container += 1;
+        delete[] buffer;
+
+        return std::optional<FrameVector>{ result };
+    }
+
+    ~XcpLogFileReader() noexcept {
+        delete m_mmap;
+    }
+
+   protected:
+
+    [[nodiscard]] blob_t const *ptr(std::uint64_t pos = 0) const {
+        return reinterpret_cast<blob_t const *>(m_mmap->data() + pos);
+    }
+
+    void read_bytes(std::uint64_t pos, std::uint64_t count, blob_t *buf) const {
+        auto addr = reinterpret_cast<char const *>(ptr(pos));
+        _fcopy(reinterpret_cast<char *>(buf), addr, count);
+    }
+
+   private:
+
+    std::string       m_file_name;
+    std::uint64_t     m_offset{ 0 };
+    std::uint64_t     m_current_container{ 0 };
+    mio::mmap_source *m_mmap{ nullptr };
+    FileHeaderType    m_header;
+    std::string       m_metadata;
+};
+
+#endif  // RECORDER_READER_HPP

pyxcp/recorder/reco.py

@@ -12,6 +12,7 @@ See
 
 -  ``_ for reading.
 """
+
 import enum
 import mmap
 import struct