pyxcp 0.23.3__cp312-cp312-win_arm64.whl → 0.25.6__cp312-cp312-win_arm64.whl

pyxcp/__init__.py

@@ -17,4 +17,4 @@ tb_install(show_locals=True, max_frames=3)  # Install custom exception handler.
 
 # if you update this manually, do not forget to update
 # .bumpversion.cfg and pyproject.toml.
-__version__ = "0.23.3"
+__version__ = "0.25.6"

pyxcp/cmdline.py

@@ -4,9 +4,8 @@ Parse (transport-layer specific) command line parameters
 and create a XCP master instance.
 """
 
+import argparse
 import warnings
-from dataclasses import dataclass
-from typing import List
 
 from pyxcp.config import (  # noqa: F401
     create_application,
@@ -14,33 +13,12 @@ from pyxcp.config import (  # noqa: F401
     reset_application,
 )
 from pyxcp.master import Master
+from pyxcp.utils.cli import StrippingParser
 
 
 warnings.simplefilter("always")
 
 
-@dataclass
-class Option:
-    short_opt: str
-    long_opt: str = ""
-    dest: str = ""
-    help: str = ""
-    type: str = ""
-    default: str = ""
-    action: str = ""
-
-
-class FakeParser:
-    """Parser that collects arguments for later processing."""
-
-    def __init__(self):
-        self.options = []
-
-    def add_argument(self, short_opt, long_opt="", dest="", help="", type=None, default=None, action=None):
-        """Collect argument definitions without issuing warnings."""
-        self.options.append(Option(short_opt, long_opt, dest, help, type, default, action))
-
-
 class ArgumentParser:
     """Argument parser for pyXCP applications.
 
@@ -49,13 +27,20 @@ class ArgumentParser:
     the parsed arguments.
     """
 
-    def __init__(self, callout=None, description=None, *args, **kws):
-        self._parser = FakeParser()
-        self._callout = callout
+    def __init__(self, user_parser=None, description=None, *args, **kws):
+        if isinstance(user_parser, argparse.ArgumentParser):
+            self._parser = StrippingParser(user_parser)
+            self._callout = None
+        else:
+            # Create a default parser. user_parser might be a callout function or None.
+            parser = argparse.ArgumentParser(description=description)
+            self._parser = StrippingParser(parser)
+            self._callout = user_parser
         self._description = description
+        self.args = self._parser.parse_and_strip()
 
     def run(self, policy=None, transport_layer_interface=None):
-        """Create and configure a master instance.
+        """Create and configure a synchronous master instance.
 
         Args:
             policy: Optional policy to use for the master
@@ -65,7 +50,7 @@ class ArgumentParser:
             A configured master instance
         """
         # Create the application with custom arguments and callout
-        application = get_application(self.parser.options, self._callout)
+        application = get_application(options=[], callout=self._callout)
 
         # Create the master instance
         master = Master(
@@ -81,4 +66,4 @@ class ArgumentParser:
 
     @property
     def parser(self):
-        return self._parser
+        return self._parser.parser

pyxcp/config/__init__.py

@@ -913,6 +913,9 @@ class General(Configurable):
     connect_retries = Integer(help="Number of CONNECT retries (None for infinite retries).", allow_none=True, default_value=3).tag(
         config=True
     )
+    # Structured diagnostics dump options
+    diagnostics_on_failure = Bool(True, help="Append a structured diagnostics dump to timeout errors.").tag(config=True)
+    diagnostics_last_pdus = Integer(20, help="How many recent PDUs to include in diagnostics dump.").tag(config=True)
     seed_n_key_dll = Unicode("", allow_none=False, help="Dynamic library used for slave resource unlocking.").tag(config=True)
     seed_n_key_dll_same_bit_width = Bool(False, help="").tag(config=True)
     custom_dll_loader = Unicode(allow_none=True, default_value=None, help="Use an custom seed and key DLL loader.").tag(config=True)
@@ -1010,6 +1013,11 @@ class PyXCP(Application):
         config=True
     )
 
+    # Logging options
+    structured_logging = Bool(False, help="Emit one-line JSON logs instead of rich text.").tag(config=True)
+    # Use log_output_format to avoid clashing with traitlets.Application.log_format (a %-style template)
+    log_output_format = Enum(values=["rich", "json"], default_value="rich", help="Select logging output format.").tag(config=True)
+
     classes = List([General, Transport, CustomArgs])
 
     subcommands = dict(
@@ -1026,34 +1034,79 @@ class PyXCP(Application):
             self.subapp.start()
             exit(2)
         else:
-            has_handlers = logging.getLogger().hasHandlers()
-            if has_handlers:
-                self.log = logging.getLogger()
-                self._read_configuration(self.config_file)
-            else:
-                self._read_configuration(self.config_file)
-                self._setup_logger()
+            # Always read configuration and then set up our logger explicitly to avoid
+            # traitlets.Application default logging using an incompatible 'log_format'.
+            self._read_configuration(self.config_file)
+            try:
+                # Ensure base Application.log_format is a valid %-style template
+                # (Users might set c.PyXCP.log_format = "json" which clashes with traitlets behavior.)
+                self.log_format = "%(message)s"  # type: ignore[assignment]
+            except Exception:
+                pass
+            self._setup_logger()
         self.log.debug(f"pyxcp version: {self.version}")
 
     def _setup_logger(self):
         from pyxcp.types import Command
 
         # Remove any handlers installed by `traitlets`.
-        for hdl in self.log.handlers:
+        for hdl in list(self.log.handlers):
             self.log.removeHandler(hdl)
 
-        # formatter = logging.Formatter(fmt=self.log_format, datefmt=self.log_datefmt)
-
-        keywords = list(Command.__members__.keys()) + ["ARGS", "KWS"]  # Syntax highlight XCP commands and other stuff.
-        rich_handler = RichHandler(
-            rich_tracebacks=True,
-            tracebacks_show_locals=True,
-            log_time_format=self.log_datefmt,
-            level=self.log_level,
-            keywords=keywords,
-        )
-        # rich_handler.setFormatter(formatter)
-        self.log.addHandler(rich_handler)
+        # Decide formatter/handler based on config
+        use_json = False
+        try:
+            # Prefer explicit log_output_format; fallback to structured_logging for compatibility
+            use_json = getattr(self, "log_output_format", "rich") == "json" or getattr(self, "structured_logging", False)
+            # Backward-compat: if someone set PyXCP.log_format="json" in config, honor it here too
+            if not use_json:
+                lf = getattr(self, "log_format", None)
+                if isinstance(lf, str) and lf.lower() == "json":
+                    use_json = True
+        except Exception:
+            use_json = False
+
+        if use_json:
+
+            class JSONFormatter(logging.Formatter):
+                def format(self, record: logging.LogRecord) -> str:
+                    # Build a minimal structured payload
+                    payload = {
+                        "time": self.formatTime(record, self.datefmt),
+                        "level": record.levelname,
+                        "logger": record.name,
+                        "message": record.getMessage(),
+                    }
+                    # Include extras if present
+                    for key in ("transport", "host", "port", "protocol", "event", "command"):
+                        if hasattr(record, key):
+                            payload[key] = getattr(record, key)
+                    # Exceptions
+                    if record.exc_info:
+                        payload["exc_type"] = record.exc_info[0].__name__ if record.exc_info[0] else None
+                        payload["exc_text"] = self.formatException(record.exc_info)
+                    try:
+                        import json as _json
+
+                        return _json.dumps(payload, ensure_ascii=False)
+                    except Exception:
+                        return f"{payload}"
+
+            handler = logging.StreamHandler()
+            formatter = JSONFormatter(datefmt=self.log_datefmt)
+            handler.setFormatter(formatter)
+            handler.setLevel(self.log_level)
+            self.log.addHandler(handler)
+        else:
+            keywords = list(Command.__members__.keys()) + ["ARGS", "KWS"]  # Syntax highlight XCP commands and other stuff.
+            rich_handler = RichHandler(
+                rich_tracebacks=True,
+                tracebacks_show_locals=True,
+                log_time_format=self.log_datefmt,
+                level=self.log_level,
+                keywords=keywords,
+            )
+            self.log.addHandler(rich_handler)
 
     def initialize(self, argv=None):
         from pyxcp import __version__ as pyxcp_version

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();
 }