pyxcp 0.23.4__cp313-cp313-win_arm64.whl → 0.23.7__cp313-cp313-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.4"
+__version__ = "0.23.7"

pyxcp/cmdline.py

@@ -55,7 +55,7 @@ class ArgumentParser:
         self._description = description
 
     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

pyxcp/config/__init__.py

@@ -913,6 +913,10 @@ 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 +1014,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 +1035,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/daq_stim/__init__.py

@@ -33,6 +33,8 @@ class DaqProcessor:
     def __init__(self, daq_lists: List[DaqList]):
         self.daq_lists = daq_lists
         self.log = get_application().log
+        # Flag indicating a fatal OS-level error occurred during DAQ (e.g., disk full, out-of-memory)
+        self._fatal_os_error: bool = False
 
     def setup(self, start_datetime: Optional[CurrentDatetime] = None, write_multiple: bool = True):
         if not self.xcp_master.slaveProperties.supportsDaq:
@@ -163,6 +165,31 @@ class DaqProcessor:
         self.xcp_master.startStopSynch(0x01)
 
     def stop(self):
+        # If a fatal OS error occurred during acquisition, skip sending stop to the slave to avoid
+        # cascading timeouts/unrecoverable errors and shut down transport gracefully instead.
+        if getattr(self, "_fatal_os_error", False):
+            try:
+                self.log.error(
+                    "DAQ stop skipped due to previous fatal OS error (e.g., disk full or out-of-memory). Closing transport."
+                )
+            except Exception:
+                pass
+            try:
+                # Best-effort: stop listener and close transport so threads finish cleanly.
+                if hasattr(self.xcp_master, "transport") and self.xcp_master.transport is not None:
+                    # Signal listeners to stop
+                    try:
+                        if hasattr(self.xcp_master.transport, "closeEvent"):
+                            self.xcp_master.transport.closeEvent.set()
+                    except Exception:
+                        pass
+                    # Close transport connection
+                    try:
+                        self.xcp_master.transport.close()
+                    except Exception:
+                        pass
+            finally:
+                return
         self.xcp_master.startStopSynch(0x00)
 
     def first_pids(self):
@@ -218,7 +245,40 @@ class DaqToCsv(DaqOnlinePolicy):
             out_file.write(f"{hdr}\n")
 
     def on_daq_list(self, daq_list: int, timestamp0: int, timestamp1: int, payload: list):
-        self.files[daq_list].write(f"{timestamp0},{timestamp1},{', '.join([str(x) for x in payload])}\n")
+        # Guard against hard OS errors (e.g., disk full) during file writes.
+        if getattr(self, "_fatal_os_error", False):
+            return
+        try:
+            self.files[daq_list].write(f"{timestamp0},{timestamp1},{', '.join([str(x) for x in payload])}\n")
+        except (OSError, MemoryError) as ex:
+            # Mark fatal condition to alter shutdown path and avoid further writes/commands.
+            self._fatal_os_error = True
+            try:
+                self.log.critical(f"DAQ file write failed: {ex.__class__.__name__}: {ex}. Initiating graceful shutdown.")
+            except Exception:
+                pass
+            # Stop listener to prevent more DAQ traffic and avoid thread crashes.
+            try:
+                if hasattr(self.xcp_master, "transport") and self.xcp_master.transport is not None:
+                    if hasattr(self.xcp_master.transport, "closeEvent"):
+                        self.xcp_master.transport.closeEvent.set()
+            except Exception:
+                pass
+            # Best-effort: close any opened files to flush buffers and release resources.
+            try:
+                for f in getattr(self, "files", {}).values():
+                    try:
+                        f.flush()
+                    except Exception:
+                        pass
+                    try:
+                        f.close()
+                    except Exception:
+                        pass
+            except Exception:
+                pass
+            # Do not re-raise; allow the system to continue to a controlled shutdown.
+            return
 
     def finalize(self):
         self.log.debug("DaqCsv::finalize()")

pyxcp/examples/run_daq.py

@@ -149,7 +149,7 @@ with ap.run(policy=daq_parser) as x:
     print("start DAQ lists.")
     daq_parser.start()  # Start DAQ lists.
 
-    time.sleep(5.0 * 60.0)  # Run for 15 minutes.
+    time.sleep(2.0 * 60.0 * 60.0)  # Run for 15 minutes.
 
     print("Stop DAQ....")
     daq_parser.stop()  # Stop DAQ lists.

pyxcp/master/errorhandler.py

@@ -17,6 +17,26 @@ from pyxcp.types import COMMAND_CATEGORIES, XcpError, XcpResponseError, XcpTimeo
 
 handle_errors = True  # enable/disable XCP error-handling.
 
+# Thread-local flag to suppress logging for expected XCP negative responses
+import threading
+
+
+_thread_flags = threading.local()
+
+
+def set_suppress_xcp_error_log(value: bool) -> None:
+    try:
+        _thread_flags.suppress_xcp_error_log = bool(value)
+    except Exception:
+        pass
+
+
+def is_suppress_xcp_error_log() -> bool:
+    try:
+        return bool(getattr(_thread_flags, "suppress_xcp_error_log", False))
+    except Exception:
+        return False
+
 
 class SingletonBase:
     _lock = threading.Lock()
@@ -196,6 +216,35 @@ class Handler:
         self._repeater = None
         self.logger = logging.getLogger("PyXCP")
 
+    def _diagnostics_enabled(self) -> bool:
+        try:
+            app = getattr(self.instance, "config", None)
+            if app is None:
+                return True
+            general = getattr(app, "general", None)
+            if general is None:
+                return True
+            return bool(getattr(general, "diagnostics_on_failure", True))
+        except Exception:
+            return True
+
+    def _build_transport_diagnostics(self) -> str:
+        try:
+            transport = getattr(self.instance, "transport", None)
+            if transport is None:
+                return ""
+            if hasattr(transport, "_build_diagnostics_dump"):
+                return transport._build_diagnostics_dump()  # type: ignore[attr-defined]
+        except Exception:
+            pass
+        return ""
+
+    def _append_diag(self, msg: str) -> str:
+        if not self._diagnostics_enabled():
+            return msg
+        diag = self._build_transport_diagnostics()
+        return msg + ("\n" + diag if diag else "")
+
     def __str__(self):
         return f"Handler(func = {func_name(self.func)} -- {self.arguments} service = {self.service} error_code = {self.error_code})"
 
@@ -268,16 +317,16 @@ class Handler:
             if item == Action.NONE:
                 pass
             elif item == Action.DISPLAY_ERROR:
-                raise SystemExit("Could not proceed due to unhandled error (DISPLAY_ERROR).", self.error_code)
+                raise SystemExit(self._append_diag("Could not proceed due to unhandled error (DISPLAY_ERROR)."), self.error_code)
             elif item == Action.RETRY_SYNTAX:
-                raise SystemExit("Could not proceed due to unhandled error (RETRY_SYNTAX).", self.error_code)
+                raise SystemExit(self._append_diag("Could not proceed due to unhandled error (RETRY_SYNTAX)."), self.error_code)
             elif item == Action.RETRY_PARAM:
-                raise SystemExit("Could not proceed due to unhandled error (RETRY_PARAM).", self.error_code)
+                raise SystemExit(self._append_diag("Could not proceed due to unhandled error (RETRY_PARAM)."), self.error_code)
             elif item == Action.USE_A2L:
-                raise SystemExit("Could not proceed due to unhandled error (USE_A2L).", self.error_code)
+                raise SystemExit(self._append_diag("Could not proceed due to unhandled error (USE_A2L)."), self.error_code)
             elif item == Action.USE_ALTERATIVE:
                 raise SystemExit(
-                    "Could not proceed due to unhandled error (USE_ALTERATIVE).", self.error_code
+                    self._append_diag("Could not proceed due to unhandled error (USE_ALTERATIVE)."), self.error_code
                 )  # TODO: check alternatives.
             elif item == Action.REPEAT:
                 repetitionCount = Repeater.REPEAT
@@ -286,13 +335,15 @@ class Handler:
             elif item == Action.REPEAT_INF_TIMES:
                 repetitionCount = Repeater.INFINITE
             elif item == Action.RESTART_SESSION:
-                raise SystemExit("Could not proceed due to unhandled error (RESTART_SESSION).", self.error_code)
+                raise SystemExit(self._append_diag("Could not proceed due to unhandled error (RESTART_SESSION)."), self.error_code)
             elif item == Action.TERMINATE_SESSION:
-                raise SystemExit("Could not proceed due to unhandled error (TERMINATE_SESSION).", self.error_code)
+                raise SystemExit(
+                    self._append_diag("Could not proceed due to unhandled error (TERMINATE_SESSION)."), self.error_code
+                )
             elif item == Action.SKIP:
                 pass
             elif item == Action.NEW_FLASH_WARE:
-                raise SystemExit("Could not proceed due to unhandled error (NEW_FLASH_WARE)", self.error_code)
+                raise SystemExit(self._append_diag("Could not proceed due to unhandled error (NEW_FLASH_WARE)"), self.error_code)
         return result_pre_actions, result_actions, Repeater(repetitionCount)
 
 
@@ -366,6 +417,48 @@ class Executor(SingletonBase):
                     # self.logger.critical(f"XcpResponseError [{e.get_error_code()}]")
                     self.error_code = e.get_error_code()
                     handler.error_code = self.error_code
+                    try:
+                        svc = getattr(inst.service, "name", None)
+                        # Derive a human-friendly error name if available
+                        try:
+                            err_name = (
+                                getattr(XcpError, int(self.error_code)).name
+                                if hasattr(XcpError, "__members__")
+                                else str(self.error_code)
+                            )
+                        except Exception:
+                            # Fallbacks: try enum-style .name or string conversion
+                            err_name = getattr(self.error_code, "name", None) or str(self.error_code)
+                        try:
+                            err_code_int = int(self.error_code)
+                        except Exception:
+                            err_code_int = self.error_code  # best effort
+                        msg = f"XCP negative response: {err_name} (0x{err_code_int:02X})"
+                        if svc:
+                            msg += f" on service {svc}"
+                        # Suppress noisy ERROR log if requested by caller context
+                        if is_suppress_xcp_error_log():
+                            self.logger.debug(
+                                msg,
+                                extra={
+                                    "event": "xcp_error_suppressed",
+                                    "service": svc,
+                                    "error_code": err_code_int,
+                                    "error_name": err_name,
+                                },
+                            )
+                        else:
+                            self.logger.error(
+                                msg,
+                                extra={
+                                    "event": "xcp_error",
+                                    "service": svc,
+                                    "error_code": err_code_int,
+                                    "error_name": err_name,
+                                },
+                            )
+                    except Exception:
+                        pass
                 except XcpTimeoutError:
                     is_connect = func.__name__ == "connect"
                     self.logger.warning(f"XcpTimeoutError -- Service: {func.__name__!r}")
@@ -405,9 +498,21 @@ class Executor(SingletonBase):
                     if handler.repeater.repeat():
                         continue
                     else:
-                        raise UnrecoverableError(
-                            f"Max. repetition count reached while trying to execute service {handler.func.__name__!r}."
-                        )
+                        msg = f"Max. repetition count reached while trying to execute service {handler.func.__name__!r}."
+                        # Try to append diagnostics from the transport
+                        try:
+                            if hasattr(handler, "_append_diag"):
+                                msg = handler._append_diag(msg)
+                        except Exception:
+                            pass
+                        try:
+                            self.logger.error(
+                                "XCP unrecoverable",
+                                extra={"event": "xcp_unrecoverable", "service": getattr(inst.service, "name", None)},
+                            )
+                        except Exception:
+                            pass
+                        raise UnrecoverableError(msg)
         finally:
             # cleanup of class variables
             self.previous_error_code = None

pyxcp/master/master.py

@@ -25,7 +25,13 @@ from pyxcp.constants import (
     makeWordUnpacker,
 )
 from pyxcp.daq_stim.stim import DaqEventInfo, Stim
-from pyxcp.master.errorhandler import SystemExit, disable_error_handling, wrapped
+from pyxcp.master.errorhandler import (
+    SystemExit,
+    disable_error_handling,
+    is_suppress_xcp_error_log,
+    set_suppress_xcp_error_log,
+    wrapped,
+)
 from pyxcp.transport.base import create_transport
 from pyxcp.utils import decode_bytes, delay, short_sleep
 
@@ -1972,6 +1978,9 @@ class Master:
         is normal for this kind of applications -- or to test for optional commands.
         Use carefuly not to hide serious error causes.
         """
+        # Suppress logging of expected XCP negative responses during try_command
+        _prev_suppress = is_suppress_xcp_error_log()
+        set_suppress_xcp_error_log(True)
         try:
             extra_msg: Optional[str] = kws.get("extra_msg")
             if extra_msg:
@@ -1985,6 +1994,8 @@ class Master:
                 silent = False
             res = cmd(*args, **kws)
         except SystemExit as e:
+            # restore suppression flag before handling
+            set_suppress_xcp_error_log(_prev_suppress)
             # print(f"\tUnexpected error while executing command {cmd.__name__!r}: {e!r}")
             if e.error_code == types.XcpError.ERR_CMD_UNKNOWN:
                 # This is a rather common use-case, so let the user know that there is some functionality missing.
@@ -2000,6 +2011,12 @@ class Master:
             return (types.TryCommandResult.OTHER_ERROR, e)
         else:
             return (types.TryCommandResult.OK, res)
+        finally:
+            # Ensure suppression flag is restored even on success/other exceptions
+            try:
+                set_suppress_xcp_error_log(_prev_suppress)
+            except Exception:
+                pass
 
 
 def ticks_to_seconds(ticks, resolution):

pyxcp/recorder/__init__.py

@@ -16,12 +16,9 @@ else:
     HAS_PANDAS = True
 
 from pyxcp.recorder.rekorder import DaqOnlinePolicy  # noqa: F401
-from pyxcp.recorder.rekorder import (
-    DaqRecorderPolicy,      # noqa: F401
-    Deserializer,           # noqa: F401
-    MeasurementParameters,  # noqa: F401
-    ValueHolder,            # 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