pyxcp 0.25.1__cp314-cp314-macosx_11_0_arm64.whl → 0.25.9__cp314-cp314-macosx_11_0_arm64.whl

pyxcp/daq_stim/__init__.py

@@ -1,11 +1,14 @@
 #!/usr/bin/env python
 
+from contextlib import suppress
+import json
 from time import time_ns
-from typing import Dict, List, Optional, TextIO, Union
+from typing import Any, Dict, List, Optional, TextIO, Tuple, Union
+
+from pyxcp.cpp_ext.cpp_ext import DaqList, PredefinedDaqList
 
 from pyxcp import types
 from pyxcp.config import get_application
-from pyxcp.cpp_ext.cpp_ext import DaqList, PredefinedDaqList
 from pyxcp.daq_stim.optimize import make_continuous_blocks
 from pyxcp.daq_stim.optimize.binpacking import first_fit_decreasing
 from pyxcp.recorder import DaqOnlinePolicy as _DaqOnlinePolicy
@@ -27,6 +30,83 @@ DAQ_TIMESTAMP_SIZE = {
 }
 
 
+def load_daq_lists_from_json(file_path: str) -> List[DaqList]:
+    """Load and validate DAQ-list from JSON file."""
+    with open(file_path, "r", encoding="utf-8") as f:
+        config = json.load(f)
+
+    if not isinstance(config, list):
+        raise ValueError("DAQ configuration must be a JSON array (list)")
+
+    daq_lists: List[DaqList] = []
+    for idx, entry in enumerate(config):
+        if not isinstance(entry, dict):
+            raise TypeError(f"Entry {idx} must be an object/dict")
+
+        required = {"name", "event_num", "stim", "enable_timestamps", "measurements", "priority", "prescaler"}
+        missing = required - set(entry.keys())
+        if missing:
+            raise ValueError(f"Entry {idx} missing required keys: {missing}")
+
+        # Basic type conversions / checks
+        name = entry["name"]
+        if not isinstance(name, str):
+            raise TypeError(f"Entry {idx} 'name' must be a string")
+
+        try:
+            event_num = int(entry["event_num"])
+        except Exception as e:
+            raise TypeError(f"Entry {idx} 'event_num' must be an integer") from e
+
+        stim = bool(entry["stim"])
+        enable_timestamps = bool(entry["enable_timestamps"])
+
+        try:
+            priority = int(entry["priority"])
+            prescaler = int(entry["prescaler"])
+        except Exception as e:
+            raise TypeError(f"Entry {idx} 'priority' and 'prescaler' must be integers") from e
+
+        measurements_raw = entry["measurements"]
+        if not isinstance(measurements_raw, list):
+            raise TypeError(f"Entry {idx} 'measurements' must be a list")
+
+        measurements: List[Tuple[str, int, int, str]] = []
+        for m_idx, m in enumerate(measurements_raw):
+            if not (isinstance(m, (list, tuple)) and len(m) == 4):
+                raise ValueError(f"Entry {idx} measurement {m_idx} must be a 4-element list/tuple")
+            m_name, m_addr, m_offset, m_type = m
+
+            if not isinstance(m_name, str):
+                raise TypeError(f"Entry {idx} measurement {m_idx} name must be a string")
+            try:
+                m_addr = int(m_addr)
+            except Exception as e:
+                raise TypeError(f"Entry {idx} measurement {m_idx} address must be an integer") from e
+            try:
+                m_offset = int(m_offset)
+            except Exception as e:
+                raise TypeError(f"Entry {idx} measurement {m_idx} offset must be an integer") from e
+            if not isinstance(m_type, str):
+                raise TypeError(f"Entry {idx} measurement {m_idx} type must be a string")
+
+            measurements.append((m_name, m_addr, m_offset, m_type))
+
+        daq_kwargs: Dict[str, Any] = {
+            "name": name,
+            "event_num": event_num,
+            "stim": stim,
+            "enable_timestamps": enable_timestamps,
+            "measurements": measurements,
+            "priority": priority,
+            "prescaler": prescaler,
+        }
+
+        daq_lists.append(DaqList(**daq_kwargs))
+
+    return daq_lists
+
+
 class DaqProcessor:
     def __init__(self, daq_lists: List[Union[DaqList, PredefinedDaqList]]):
         self.daq_lists = daq_lists
@@ -74,14 +154,13 @@ class DaqProcessor:
             self.selectable_timestamps = False
             max_payload_size_first = max_payload_size
             if not self.supports_timestampes:
-                # print("NO TIMESTAMP SUPPORT")
-                pass
+                self.log.info("No timestamp support")
             else:
                 if self.ts_fixed:
-                    # print("Fixed timestamp")
+                    self.log.debug("Fixed timestamps")
                     max_payload_size_first = max_payload_size - self.ts_size
                 else:
-                    # print("timestamp variable.")
+                    self.log.debug("Variable timestamps.")
                     self.selectable_timestamps = True
         except Exception as e:
             raise TypeError(f"DAQ_INFO corrupted: {e}") from e
@@ -159,8 +238,6 @@ class DaqProcessor:
             )
             res = self.xcp_master.startStopDaqList(0x02, i)
             self._first_pids.append(res.firstPid)
-        if start_datetime:
-            pass
         self.measurement_params = MeasurementParameters(
             byte_order,
             header_len,
@@ -184,26 +261,21 @@ class DaqProcessor:
         # 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:
+            with suppress(Exception):
                 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  # nosec
             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:
+                    with suppress(Exception):
                         if hasattr(self.xcp_master.transport, "closeEvent"):
                             self.xcp_master.transport.closeEvent.set()
-                    except Exception:
-                        pass  # nosec
+
                     # Close transport connection
-                    try:
+                    with suppress(Exception):
                         self.xcp_master.transport.close()
-                    except Exception:
-                        pass  # nosec
             finally:
                 return
         self.xcp_master.startStopSynch(0x00)
@@ -268,30 +340,21 @@ class DaqToCsv(DaqOnlinePolicy):
         except (OSError, MemoryError) as ex:
             # Mark fatal condition to alter shutdown path and avoid further writes/commands.
             self._fatal_os_error = True
-            try:
+            with suppress(Exception):
                 self.log.critical(f"DAQ file write failed: {ex.__class__.__name__}: {ex}. Initiating graceful shutdown.")
-            except Exception:
-                pass  # nosec
+
             # Stop listener to prevent more DAQ traffic and avoid thread crashes.
-            try:
+            with suppress(Exception):
                 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  # nosec
             # Best-effort: close any opened files to flush buffers and release resources.
-            try:
+            with suppress(Exception):
                 for f in getattr(self, "files", {}).values():
-                    try:
+                    with suppress(Exception):
                         f.flush()
-                    except Exception:
-                        pass  # nosec
-                    try:
+                    with suppress(Exception):
                         f.close()
-                    except Exception:
-                        pass  # nosec
-            except Exception:
-                pass  # nosec
             # Do not re-raise; allow the system to continue to a controlled shutdown.
             return
 

pyxcp/daq_stim/optimize/binpacking.py

@@ -1,6 +1,6 @@
 #!/usr/bin/env python
-"""Bin-packing algorithms.
-"""
+"""Bin-packing algorithms."""
+
 from typing import List, Optional
 
 from pyxcp.cpp_ext.cpp_ext import Bin

pyxcp/daq_stim/scheduler.cpp

@@ -10,10 +10,10 @@ VOID CALLBACK TimerRoutine(PVOID lpParam, BOOLEAN TimerOrWaitFired) {
         std::printf("TimerRoutine lpParam is NULL\n");
         return;
     }
-    
+
     const auto* param = static_cast<const int*>(lpParam);
     std::printf("Timer routine called. Parameter is %d.\n", *param);
-    
+
     if (TimerOrWaitFired) {
         std::printf("The wait timed out.\n");
     } else {
@@ -30,10 +30,10 @@ namespace {
 
 #if defined(_M_X64) || defined(_M_IX86) || defined(__SSE__)
     #include <xmmintrin.h>
-    
+
     void mul4_vectorized(float* ptr) {
         if (ptr == nullptr) return;
-        
+
         __m128 f = _mm_loadu_ps(ptr);
         f = _mm_mul_ps(f, f);
         _mm_storeu_ps(ptr, f);
@@ -41,10 +41,10 @@ namespace {
 
 #elif defined(_M_ARM64) || defined(__ARM_NEON)
     #include <arm_neon.h>
-    
+
     void mul4_vectorized(float* ptr) {
         if (ptr == nullptr) return;
-        
+
         float32x4_t f = vld1q_f32(ptr);
         f = vmulq_f32(f, f);
         vst1q_f32(ptr, f);
@@ -54,9 +54,9 @@ namespace {
     // Scalar fallback
     void mul4_vectorized(float* ptr) {
         if (ptr == nullptr) return;
-        
+
         for (size_t i = 0; i < VECTOR_SIZE; ++i) {
             ptr[i] *= ptr[i];
         }
     }
-#endif
+#endif

pyxcp/errormatrix.py

@@ -1,6 +1,6 @@
 #!/usr/bin/env python
-"""Types and structures to support error-handling as specified by XCP.
-"""
+"""Types and structures to support error-handling as specified by XCP."""
+
 import enum
 from collections import namedtuple
 

pyxcp/examples/xcp_read_benchmark.py

@@ -1,6 +1,6 @@
 #!/usr/bin/env python
-"""Very basic hello-world example.
-"""
+"""Very basic hello-world example."""
+
 import time
 
 import matplotlib.pyplot as plt

pyxcp/examples/xcp_skel.py

@@ -1,6 +1,5 @@
 #!/usr/bin/env python
-"""Use this as a copy-and-paste template for your own scripts.
-"""
+"""Use this as a copy-and-paste template for your own scripts."""
 
 from pyxcp.cmdline import ArgumentParser
 

pyxcp/examples/xcp_unlock.py

@@ -1,20 +1,13 @@
 #!/usr/bin/env python
-"""Very basic hello-world example.
-"""
-from pyxcp.cmdline import ArgumentParser
-
-
-"""
-"""
+"""Very basic hello-world example."""
 
+import argparse
 
-def callout(master, args):
-    if args.sk_dll:
-        master.seedNKeyDLL = args.sk_dll
+from pyxcp.cmdline import ArgumentParser
 
 
-ap = ArgumentParser(callout)
-ap.parser.add_argument(
+parser = argparse.ArgumentParser(description="XCP unlock example")
+parser.add_argument(
     "-s",
     "--sk-dll",
     dest="sk_dll",
@@ -23,7 +16,12 @@ ap.parser.add_argument(
     default=None,
 )
 
+ap = ArgumentParser(parser)
+
 with ap.run() as x:
+    if ap.args.sk_dll:
+        x.seedNKeyDLL = ap.args.sk_dll
+
     x.connect()
 
     print("")

pyxcp/examples/xcp_user_supplied_driver.py

@@ -1,6 +1,6 @@
 #!/usr/bin/env python
 
-from typing import Dict, List, Optional
+from typing import Optional
 
 import can
 
@@ -9,7 +9,6 @@ from pyxcp.transport.can import CanInterfaceBase
 
 
 class CustomCANInterface(CanInterfaceBase):
-
     def init(self):
         """Initialize the CAN interface here."""
 

pyxcp/examples/xcphello.py

@@ -1,5 +1,6 @@
 #!/usr/bin/env python
 """Very basic hello-world example."""
+
 from pprint import pprint
 
 from pyxcp.cmdline import ArgumentParser
@@ -9,21 +10,7 @@ from pyxcp.utils import decode_bytes
 daq_info = False
 
 
-def callout(master, args):
-    global daq_info
-    if args.daq_info:
-        daq_info = True
-
-
-ap = ArgumentParser(description="pyXCP hello world.", callout=callout)
-ap.parser.add_argument(
-    "-d",
-    "--daq-info",
-    dest="daq_info",
-    help="Display DAQ-info",
-    default=False,
-    action="store_true",
-)
+ap = ArgumentParser(description="pyXCP hello world.")
 
 with ap.run() as x:
     x.connect()

pyxcp/examples/xcphello_recorder.py

@@ -1,6 +1,6 @@
 #!/usr/bin/env python
-"""Very basic hello-world example.
-"""
+"""Very basic hello-world example."""
+
 from pprint import pprint
 
 from pyxcp.cmdline import ArgumentParser

pyxcp/master/__init__.py

@@ -6,4 +6,5 @@
 
 .. [1] XCP Specification, Part 2 - Protocol Layer Specification
 """
+
 from .master import Master  # noqa: F401

pyxcp/master/master.py

@@ -6,14 +6,16 @@
 
 .. [1] XCP Specification, Part 2 - Protocol Layer Specification
 """
-from __future__ import annotations
 
 import functools
 import logging
 import struct
 import traceback
 import warnings
-from typing import Any, Callable, Collection, Dict, Optional, Tuple, TypeVar
+from contextlib import suppress
+from typing import Any, Callable, Collection, TypeVar
+
+from pyxcp.daq_stim.stim import DaqEventInfo, Stim
 
 from pyxcp import checksum, types
 from pyxcp.constants import (
@@ -26,7 +28,6 @@ from pyxcp.constants import (
     makeWordPacker,
     makeWordUnpacker,
 )
-from pyxcp.daq_stim.stim import DaqEventInfo, Stim
 from pyxcp.master.errorhandler import (
     SystemExit,
     disable_error_handling,
@@ -37,7 +38,6 @@ from pyxcp.master.errorhandler import (
 from pyxcp.transport.base import create_transport
 from pyxcp.utils import decode_bytes, delay, short_sleep
 
-
 # Type variables for better type hinting
 T = TypeVar("T")
 R = TypeVar("R")
@@ -211,7 +211,7 @@ class Master:
         self.slaveProperties.pgmProcessor = SlaveProperties()
         self.slaveProperties.transport_layer = self.transport_name.upper()
 
-    def __enter__(self) -> Master:
+    def __enter__(self):
         """Context manager entry part.
 
         This method is called when entering a context manager block.
@@ -225,9 +225,7 @@ class Master:
         self.transport.connect()
         return self
 
-    def __exit__(
-        self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: traceback.TracebackType | None
-    ) -> None:
+    def __exit__(self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb) -> None:
         """Context manager exit part.
 
         This method is called when exiting a context manager block.
@@ -541,11 +539,7 @@ class Master:
         """
         # Send GET_ID command to the slave
         response = self.transport.request(types.Command.GET_ID, mode)
-
-        # Parse the response with the correct byte order
         result = types.GetIDResponse.parse(response, byteOrder=self.slaveProperties.byteOrder)
-
-        # Extract the length from the response
         result.length = self.DWORD_unpack(response[3:7])[0]
 
         return result
@@ -751,15 +745,14 @@ class Master:
             # Larger sizes will send in multiple CAN messages
             # Each valid message will start with 0xFF followed by the upload bytes
             # The last message might be padded to the required DLC
-            remaining_bytes = byte_count - len(response)
-            while remaining_bytes:
+            remaining_bytes = byte_count - len(response)    # NOTE: Due to padding the result may negative!
+            while remaining_bytes > 0:
                 if len(self.transport.resQueue):
                     data = self.transport.resQueue.popleft()
                     response += data[1 : remaining_bytes + 1]
                     remaining_bytes = byte_count - len(response)
                 else:
                     short_sleep()
-
         return response
 
     @wrapped
@@ -2326,7 +2319,7 @@ class Master:
         if self.currentProtectionStatus is None:
             try:
                 status = self.getStatus()
-            except Exception as e:  # may temporary ERR_OUT_OF_RANGE
+            except Exception:  # may temporary ERR_OUT_OF_RANGE
                 return {"dbg": None, "pgm": None, "stim": None, "daq": None, "calpag": None}
             self._setProtectionStatus(status.resourceProtectionStatus)
         return self.currentProtectionStatus
@@ -2499,7 +2492,10 @@ class Master:
                         name = STD_IDS[id_value]
                     else:
                         name = f"USER_{idx}"
-                    yield id_value, name,
+                    yield (
+                        id_value,
+                        name,
+                    )
 
             return generate()
 
@@ -2590,10 +2586,8 @@ class Master:
             return (types.TryCommandResult.OK, res)
         finally:
             # Ensure suppression flag is restored even on success/other exceptions
-            try:
+            with suppress(Exception):
                 set_suppress_xcp_error_log(_prev_suppress)
-            except Exception:
-                pass  # nosec B110
 
 
 def ticks_to_seconds(ticks, resolution):

pyxcp/recorder/.idea/misc.xml

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

pyxcp/recorder/.idea/modules.xml

@@ -5,4 +5,4 @@
       <module fileurl="file://$PROJECT_DIR$/.idea/recorder.iml" filepath="$PROJECT_DIR$/.idea/recorder.iml" />
     </modules>
   </component>
-</project>
+</project>

pyxcp/recorder/.idea/recorder.iml

@@ -3,4 +3,4 @@
   <component name="SonarLintModuleSettings">
     <option name="uniqueId" value="ce2142a1-5ccc-4675-8d23-c6ee960ba851" />
   </component>
-</module>
+</module>

pyxcp/recorder/.idea/vcs.xml

@@ -7,4 +7,4 @@
     <mapping directory="$PROJECT_DIR$/simde" vcs="Git" />
     <mapping directory="$PROJECT_DIR$/simdjson" vcs="Git" />
   </component>
-</project>
+</project>

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: