pyxcp 0.25.4__cp313-cp313-win_amd64.whl → 0.25.8__cp313-cp313-win_amd64.whl

pyxcp/__init__.py

@@ -16,5 +16,5 @@ console = Console()
 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.25.4"
+# pyproject.toml.
+__version__ = "0.25.8"

pyxcp/cmdline.py

@@ -37,7 +37,7 @@ class ArgumentParser:
             self._parser = StrippingParser(parser)
             self._callout = user_parser
         self._description = description
-        self.args = None
+        self.args = self._parser.parse_and_strip()
 
     def run(self, policy=None, transport_layer_interface=None):
         """Create and configure a synchronous master instance.
@@ -49,8 +49,6 @@ class ArgumentParser:
         Returns:
             A configured master instance
         """
-        self.args = self._parser.parse_and_strip()
-
         # Create the application with custom arguments and callout
         application = get_application(options=[], callout=self._callout)
 

pyxcp/cpp_ext/extension_wrapper.cpp

@@ -22,6 +22,21 @@ class PyTimestampInfo : public TimestampInfo {
     using TimestampInfo::TimestampInfo;
 };
 
+py::dict mcobject_asdict(const McObject& self) {
+    py::dict d;
+    d["name"] = self.get_name();
+    d["address"] = self.get_address();
+    d["ext"] = self.get_ext();
+    d["length"] = self.get_length();
+    d["data_type"] = self.get_data_type();
+    py::list components_list;
+    for (const auto& component : self.get_components()) {
+        components_list.append(mcobject_asdict(component));
+    }
+    d["components"] = components_list;
+    return d;
+}
+
 
 PYBIND11_MODULE(cpp_ext, m) {
     m.doc() = "C++ extensions for pyXCP.";
@@ -43,6 +58,7 @@ PYBIND11_MODULE(cpp_ext, m) {
         .def_property_readonly("components", &McObject::get_components)
 
         .def("add_component", &McObject::add_component, "component"_a)
+        .def("asdict", &mcobject_asdict)
         .def("__eq__", [](const McObject& self, const McObject& other) { return self == other; })
         .def("__repr__", [](const McObject& self) { return to_string(self); })
         .def("__hash__", [](const McObject& self) { return self.get_hash(); })
@@ -54,6 +70,17 @@ PYBIND11_MODULE(cpp_ext, m) {
         .def_property("residual_capacity", &Bin::get_residual_capacity, &Bin::set_residual_capacity)
         .def_property("entries", &Bin::get_entries, nullptr)
         .def("append", &Bin::append)
+        .def("asdict", [](const Bin& self) {
+            py::dict d;
+            d["size"] = self.get_size();
+            d["residual_capacity"] = self.get_residual_capacity();
+            py::list entries_list;
+            for (const auto& entry : self.get_entries()) {
+                entries_list.append(mcobject_asdict(entry));
+            }
+            d["entries"] = entries_list;
+            return d;
+        })
         .def("__repr__", [](const Bin& self) { return to_string(self); })
         .def("__eq__", [](const Bin& self, const Bin& other) { return self == other; })
         .def("__len__", [](const Bin& self) { return std::size(self.get_entries()); });
@@ -69,7 +96,22 @@ PYBIND11_MODULE(cpp_ext, m) {
         .def_property("headers", &DaqListBase::get_headers, nullptr)
         .def_property("odt_count", &DaqListBase::get_odt_count, nullptr)
         .def_property("total_entries", &DaqListBase::get_total_entries, nullptr)
-        .def_property("total_length", &DaqListBase::get_total_length, nullptr);
+        .def_property("total_length", &DaqListBase::get_total_length, nullptr)
+        .def("asdict", [](const DaqListBase& self) {
+            py::dict d;
+            d["name"] = self.get_name();
+            d["event_num"] = self.get_event_num();
+            d["priority"] = self.get_priority();
+            d["prescaler"] = self.get_prescaler();
+            d["stim"] = self.get_stim();
+            d["enable_timestamps"] = self.get_enable_timestamps();
+            d["measurements_opt"] = self.get_measurements_opt();
+            d["headers"] = self.get_headers();
+            d["odt_count"] = self.get_odt_count();
+            d["total_entries"] = self.get_total_entries();
+            d["total_length"] = self.get_total_length();
+            return d;
+        });
 
     py::class_<DaqList, DaqListBase, std::shared_ptr<DaqList>>(m, "DaqList")
         .def(
@@ -78,7 +120,27 @@ PYBIND11_MODULE(cpp_ext, m) {
             "priority"_a=0, "prescaler"_a=1
         )
         .def("__repr__", [](const DaqList& self) { return self.to_string(); })
-        .def_property("measurements", &DaqList::get_measurements, nullptr);
+        .def_property("measurements", &DaqList::get_measurements, nullptr)
+        .def("asdict", [](const DaqList& self) {
+            py::dict d;
+            d["name"] = self.get_name();
+            d["event_num"] = self.get_event_num();
+            d["priority"] = self.get_priority();
+            d["prescaler"] = self.get_prescaler();
+            d["stim"] = self.get_stim();
+            d["enable_timestamps"] = self.get_enable_timestamps();
+            d["measurements_opt"] = self.get_measurements_opt();
+            d["headers"] = self.get_headers();
+            d["odt_count"] = self.get_odt_count();
+            d["total_entries"] = self.get_total_entries();
+            d["total_length"] = self.get_total_length();
+            py::list measurements_list;
+            for (const auto& measurement : self.get_measurements()) {
+                measurements_list.append(mcobject_asdict(measurement));
+            }
+            d["measurements"] = measurements_list;
+            return d;
+        });
 
     py::class_<PredefinedDaqList, DaqListBase, std::shared_ptr<PredefinedDaqList>>(m, "PredefinedDaqList")
         .def(
@@ -94,6 +156,21 @@ PYBIND11_MODULE(cpp_ext, m) {
             } catch (...) {
                 return std::string("PredefinedDaqList(<repr error: unknown>)");
             }
+        })
+        .def("asdict", [](const PredefinedDaqList& self) {
+            py::dict d;
+            d["name"] = self.get_name();
+            d["event_num"] = self.get_event_num();
+            d["priority"] = self.get_priority();
+            d["prescaler"] = self.get_prescaler();
+            d["stim"] = self.get_stim();
+            d["enable_timestamps"] = self.get_enable_timestamps();
+            d["measurements_opt"] = self.get_measurements_opt();
+            d["headers"] = self.get_headers();
+            d["odt_count"] = self.get_odt_count();
+            d["total_entries"] = self.get_total_entries();
+            d["total_length"] = self.get_total_length();
+            return d;
         })
 		;
 

pyxcp/daq_stim/__init__.py

@@ -1,8 +1,9 @@
 #!/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
 
@@ -29,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

pyxcp/master/master.py

@@ -13,7 +13,7 @@ import struct
 import traceback
 import warnings
 from contextlib import suppress
-from typing import Any, Callable, Collection, Dict, Optional, TypeVar
+from typing import Any, Callable, Collection, TypeVar
 
 from pyxcp.daq_stim.stim import DaqEventInfo, Stim
 
@@ -133,8 +133,7 @@ class Master:
         Custom transport layer interface, by default None
     """
 
-    def __init__(self, transport_name: str | None, config: Any, policy: Any = None,
-                 transport_layer_interface: Any = None) -> None:
+    def __init__(self, transport_name: str | None, config: Any, policy: Any = None, transport_layer_interface: Any = None) -> None:
         """Initialize a new Master instance.
 
         Parameters
@@ -168,8 +167,7 @@ class Master:
         # Set up transport layer
         self.transport_name: str = transport_name.lower()
         transport_config: Any = config.transport
-        self.transport: BaseTransport = create_transport(transport_name, transport_config, policy,
-                                                         transport_layer_interface)
+        self.transport: BaseTransport = create_transport(transport_name, transport_config, policy, transport_layer_interface)
 
         # Set up STIM (stimulation) support
         self.stim: Stim = Stim(self.config.stim_support)
@@ -227,10 +225,7 @@ class Master:
         self.transport.connect()
         return self
 
-    def __exit__(
-            self, exc_type: type[BaseException] | None, exc_val: BaseException | None,
-            exc_tb
-    ) -> 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.
@@ -750,11 +745,11 @@ 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]
+                    response += data[1 : remaining_bytes + 1]
                     remaining_bytes = byte_count - len(response)
                 else:
                     short_sleep()
@@ -1064,17 +1059,17 @@ class Master:
         )
 
     def _generalized_downloader(
-            self,
-            address: int,
-            address_ext: int,
-            data: bytes,
-            maxCto: int,
-            maxBs: int,
-            minSt: int,
-            master_block_mode: bool,
-            dl_func: Callable[[bytes, int, bool], Any],
-            dl_next_func: Callable[[bytes, int, bool], Any],
-            callback: Callable[[int], None] | None = None,
+        self,
+        address: int,
+        address_ext: int,
+        data: bytes,
+        maxCto: int,
+        maxBs: int,
+        minSt: int,
+        master_block_mode: bool,
+        dl_func: Callable[[bytes, int, bool], Any],
+        dl_next_func: Callable[[bytes, int, bool], Any],
+        callback: Callable[[int], None] | None = None,
     ) -> None:
         """Generic implementation for downloading data to the slave.
 
@@ -1138,13 +1133,13 @@ class Master:
             self._download_normal_mode(data, total_length, max_payload, offset, dl_func, callback)
 
     def _download_master_block_mode(
-            self,
-            data: bytes,
-            total_length: int,
-            max_payload: int,
-            offset: int,
-            block_downloader: Callable[[bytes], Any],
-            callback: Callable[[int], None] | None = None,
+        self,
+        data: bytes,
+        total_length: int,
+        max_payload: int,
+        offset: int,
+        block_downloader: Callable[[bytes], Any],
+        callback: Callable[[int], None] | None = None,
     ) -> None:
         """Download data using master block mode.
 
@@ -1171,7 +1166,7 @@ class Master:
 
         # Process full blocks
         for _ in blocks:
-            block = data[offset: offset + max_payload]
+            block = data[offset : offset + max_payload]
             block_downloader(block)
             offset += max_payload
             remaining -= max_payload
@@ -1183,19 +1178,19 @@ class Master:
 
         # Process remaining partial block
         if remaining_block_size:
-            block = data[offset: offset + remaining_block_size]
+            block = data[offset : offset + remaining_block_size]
             block_downloader(block)
             if callback:
                 callback(percent_complete)
 
     def _download_normal_mode(
-            self,
-            data: bytes,
-            total_length: int,
-            max_payload: int,
-            offset: int,
-            dl_func: Callable[[bytes, int, bool], Any],
-            callback: Callable[[int], None] | None = None,
+        self,
+        data: bytes,
+        total_length: int,
+        max_payload: int,
+        offset: int,
+        dl_func: Callable[[bytes, int, bool], Any],
+        callback: Callable[[int], None] | None = None,
     ) -> None:
         """Download data using normal mode.
 
@@ -1223,7 +1218,7 @@ class Master:
 
         # Process full chunks
         for _ in chunks:
-            block = data[offset: offset + max_payload]
+            block = data[offset : offset + max_payload]
             dl_func(block, max_payload, last=False)
             offset += max_payload
             callback_remaining -= chunk_size
@@ -1235,17 +1230,17 @@ class Master:
 
         # Process remaining partial chunk
         if remaining:
-            block = data[offset: offset + remaining]
+            block = data[offset : offset + remaining]
             dl_func(block, remaining, last=True)
             if callback:
                 callback(percent_complete)
 
     def _block_downloader(
-            self,
-            data: bytes,
-            dl_func: Callable[[bytes, int, bool], Any] | None = None,
-            dl_next_func: Callable[[bytes, int, bool], Any] | None = None,
-            minSt: float = 0.0,
+        self,
+        data: bytes,
+        dl_func: Callable[[bytes, int, bool], Any] | None = None,
+        dl_next_func: Callable[[bytes, int, bool], Any] | None = None,
+        minSt: float = 0.0,
     ) -> None:
         """Re-usable block downloader for transferring data in blocks.
 
@@ -1279,7 +1274,7 @@ class Master:
         index = 0
         for index in packets:
             # Extract packet data
-            packet_data = data[offset: offset + max_packet_size]
+            packet_data = data[offset : offset + max_packet_size]
 
             # Determine if this is the last packet
             last = (remaining_block_size - max_packet_size) == 0
@@ -1302,7 +1297,7 @@ class Master:
         # Process remaining partial packet
         if remaining:
             # Extract remaining data
-            packet_data = data[offset: offset + remaining]
+            packet_data = data[offset : offset + remaining]
 
             # Send packet using appropriate function
             if index == 0:
@@ -1745,8 +1740,7 @@ class Master:
 
     @wrapped
     def setDaqPackedMode(
-            self, daq_list_number: int, daq_packed_mode: int, dpm_timestamp_mode: int = None,
-            dpm_sample_count: int = None
+        self, daq_list_number: int, daq_packed_mode: int, dpm_timestamp_mode: int = None, dpm_sample_count: int = None
     ):
         """Set DAQ List Packed Mode.
 
@@ -1921,8 +1915,7 @@ class Master:
         return self.transport.request(types.Command.PROGRAM_PREPARE, 0x00, *cs)
 
     @wrapped
-    def programFormat(self, compression_method: int, encryption_method: int, programming_method: int,
-                      access_method: int):
+    def programFormat(self, compression_method: int, encryption_method: int, programming_method: int, access_method: int):
         return self.transport.request(
             types.Command.PROGRAM_FORMAT,
             compression_method,
@@ -2190,8 +2183,7 @@ class Master:
     @wrapped
     def timeCorrelationProperties(self, set_properties: int, get_properties_request: int, cluster_id: int):
         response = self.transport.request(
-            types.Command.TIME_CORRELATION_PROPERTIES, set_properties, get_properties_request, 0,
-            *self.WORD_pack(cluster_id)
+            types.Command.TIME_CORRELATION_PROPERTIES, set_properties, get_properties_request, 0, *self.WORD_pack(cluster_id)
         )
         return types.TimeCorrelationPropertiesResponse.parse(response, byteOrder=self.slaveProperties.byteOrder)
 
@@ -2327,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
@@ -2372,8 +2364,7 @@ class Master:
 
         protection_status = self.getCurrentProtectionStatus()
         if any(protection_status.values()) and (not (self.seed_n_key_dll or self.seed_n_key_function)):
-            raise RuntimeError(
-                "Neither seed-and-key DLL nor function specified, cannot proceed.")  # TODO: ConfigurationError
+            raise RuntimeError("Neither seed-and-key DLL nor function specified, cannot proceed.")  # TODO: ConfigurationError
         if resources is None:
             result = []
             if self.slaveProperties["supportsCalpag"]:
@@ -2501,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()
 
@@ -2623,7 +2617,7 @@ def make_tick_converter(resolution):
     """
     exponent = types.DAQ_TIMESTAMP_UNIT_TO_EXP[resolution.timestampMode.unit]
     tick_resolution = resolution.timestampTicks
-    base = (10 ** exponent) * tick_resolution
+    base = (10**exponent) * tick_resolution
 
     def ticks_to_seconds(ticks):
         """Convert DAQ timestamp/tick value to seconds.

pyxcp/scripts/xcp_daq_recorder.py

@@ -0,0 +1,54 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+import argparse
+import sys
+import time
+
+from pyxcp.cmdline import ArgumentParser
+from pyxcp.daq_stim import DaqList, DaqRecorder, DaqToCsv, load_daq_lists_from_json  # noqa: F401
+from pyxcp.types import XcpTimeoutError
+
+parser = argparse.ArgumentParser(description="XCP DAQ list recorder")
+parser.add_argument(
+    "DAQ_configuration_file",
+    type=str,
+    default=None,
+)
+
+ap = ArgumentParser(description="XCP DAQ list recorder", user_parser=parser)
+
+args = ap.args
+DAQ_LISTS = load_daq_lists_from_json(args.DAQ_configuration_file)
+
+# daq_parser = DaqToCsv(DAQ_LISTS)  # Record to CSV file(s).
+daq_parser = DaqRecorder(DAQ_LISTS, "run_daq_21092025_01", 8)  # Record to ".xmraw" file.
+
+with ap.run(policy=daq_parser) as x:
+    try:
+        x.connect()
+    except XcpTimeoutError:
+        sys.exit(2)
+
+    if x.slaveProperties.optionalCommMode:
+        x.getCommModeInfo()
+
+    x.cond_unlock("DAQ")  # DAQ resource is locked in many cases.
+
+    print("setup DAQ lists.")
+    daq_parser.setup()  # Execute setup procedures.
+    print("start DAQ lists.")
+    daq_parser.start()  # Start DAQ lists.
+
+    time.sleep(0.25 * 60.0 * 60.0)  # Run for 15 minutes.
+
+    print("Stop DAQ....")
+    daq_parser.stop()  # Stop DAQ lists.
+    print("finalize DAQ lists.\n")
+    x.disconnect()
+
+if hasattr(daq_parser, "files"):  # `files` attribute is specific to `DaqToCsv`.
+    print("Data written to:")
+    print("================")
+    for fl in daq_parser.files.values():
+        print(fl.name)

pyxcp/transport/hdf5_policy.py

@@ -1,12 +1,13 @@
 #!/usr/bin/env python
 
+import datetime
 from pathlib import Path
 from typing import List, Dict
 
 import h5py
 import numpy as np
 from pyxcp.daq_stim import DaqOnlinePolicy, DaqList
-
+from pyxcp import __version__ as pyxcp_version
 
 BATCH_SIZE = 4096
 
@@ -25,6 +26,21 @@ MAP_TO_NP = {
     "BF16": np.float16,
 }
 
+MAP_TO_ASAM_HO = {
+    "U8": "A_UINT8",
+    "I8": "A_INT8",
+    "U16": "A_UINT16",
+    "I16": "A_INT16",
+    "U32": "A_UINT32",
+    "I32": "A_INT32",
+    "U64": "A_UINT64",
+    "I64": "A_INT64",
+    "F32": "A_FLOAT32",
+    "F64": "A_FLOAT64",
+    "F16": "A_FLOAT16",
+    "BF16": "A_FLOAT16",
+}
+
 
 class BufferedDataset:
     def __init__(self, dataset: h5py.Dataset):
@@ -72,22 +88,35 @@ class DatasetGroup:
 
 
 def create_timestamp_column(hdf_file: h5py.File, group_name: str, num: int) -> h5py.Dataset:
-    return hdf_file.create_dataset(
+    result = hdf_file.create_dataset(
         f"/{group_name}/timestamp{num}",
         shape=(0,),
         maxshape=(None,),
         dtype=np.uint64,
         chunks=True,
     )
+    result.attrs["asam_data_type"] = "A_UINT64"
+    result.attrs["resolution"] = ("1 nanosecond",)
+    return result
 
 
 class Hdf5OnlinePolicy(DaqOnlinePolicy):
-    def __init__(self, file_name: str | Path, daq_lists: List[DaqList]):
+    def __init__(self, file_name: str | Path, daq_lists: List[DaqList], **metadata):
         super().__init__(daq_lists=daq_lists)
         path = Path(file_name)
         if path.suffix != ".h5":
             path = path.with_suffix(".h5")
         self.hdf = h5py.File(path, "w", libver="latest")
+        self.metadata = self.set_metadata(**metadata)
+
+    def set_metadata(self, **metadata):
+        basic = {
+            "tool_name": "pyXCP",
+            "tool_version": f"{pyxcp_version}",
+            "created": f"{datetime.datetime.now().astimezone().isoformat()}",
+        }
+        for k, v in (basic | metadata).items():
+            self.hdf.attrs[k] = v
 
     def initialize(self):
         self.log.debug("Hdf5OnlinePolicy::Initialize()")
@@ -95,7 +124,12 @@ class Hdf5OnlinePolicy(DaqOnlinePolicy):
         for num, daq_list in enumerate(self.daq_lists):
             if daq_list.stim:
                 continue
-            self.hdf.create_group(daq_list.name)
+            grp = self.hdf.create_group(daq_list.name)
+            grp.attrs["event_num"] = daq_list.event_num
+            grp.attrs["enable_timestamps"] = daq_list.enable_timestamps
+            grp.attrs["prescaler"] = daq_list.prescaler
+            grp.attrs["priority"] = daq_list.priority
+            grp.attrs["direction"] = "STIM" if daq_list.stim else "DAQ"
             ts0 = BufferedDataset(create_timestamp_column(self.hdf, daq_list.name, 0))
             ts1 = BufferedDataset(create_timestamp_column(self.hdf, daq_list.name, 1))
             meas_map = {m.name: m for m in self.daq_lists[num].measurements}
@@ -103,12 +137,16 @@ class Hdf5OnlinePolicy(DaqOnlinePolicy):
             for name, _ in daq_list.headers:
                 meas = meas_map[name]
                 dataset = self.hdf.create_dataset(
-                    f"/{daq_list.name}/{meas.name}",
+                    f"/{daq_list.name}/{meas.name}/raw",
                     shape=(0,),
                     maxshape=(None,),
                     dtype=MAP_TO_NP[meas.data_type],
                     chunks=(1024,),
                 )
+                sub_group = dataset.parent
+                sub_group.attrs["asam_data_type"] = MAP_TO_ASAM_HO.get(meas.data_type, "n/a")
+                dataset.attrs["ecu_address"] = meas.address
+                dataset.attrs["ecu_address_extension"] = meas.ext
                 dsets.append(BufferedDataset(dataset))
             self.datasets[num] = DatasetGroup(ts0_ds=ts0, ts1_ds=ts1, datasets=dsets)
         self.hdf.flush()

{pyxcp-0.25.4.dist-info → pyxcp-0.25.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyxcp
-Version: 0.25.4
+Version: 0.25.8
 Summary: Universal Calibration Protocol for Python
 License: LGPLv3
 License-File: LICENSE

{pyxcp-0.25.4.dist-info → pyxcp-0.25.8.dist-info}/RECORD

@@ -1,4 +1,4 @@
-pyxcp/__init__.py,sha256=ObYrIi4LzK61FvVRRAtNbs7Xsm-b8_QDiqDszh0ACAQ,547
+pyxcp/__init__.py,sha256=Bm5vH6ppREERjuTwbs9IGEjoHsSTUs15ypEoXyNb5YM,526
 pyxcp/aml/EtasCANMonitoring.a2l,sha256=EJYwe3Z3H24vyWAa6lUgcdKnQY8pwFxjyCN6ZU1ST8w,1509
 pyxcp/aml/EtasCANMonitoring.aml,sha256=xl0DdyeiIaLW0mmmJNAyJS0CQdOLSxt9dxfgrdSlU8Y,2405
 pyxcp/aml/ifdata_CAN.a2l,sha256=NCUnCUEEgRbZYSLGtUGwL2e7zJ8hrp0SbmLHGv8uY58,612
@@ -15,10 +15,10 @@ pyxcp/aml/XCPonUSB.aml,sha256=Xcu52ZckyuEX0v5rwYQxz8gJCAs4qyepXmd_bkCJVlA,4953
 pyxcp/asam/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pyxcp/asam/types.py,sha256=_gKcpBF5mon_SDWZBUW0PGBMcb37yrvhhEuk1wslg-s,2441
 pyxcp/asamkeydll.c,sha256=dVEvU0S1kgIo62S0La-T8xHSw668LM_DYc_fiQ0No6g,2952
-pyxcp/asamkeydll.exe,sha256=0ZFD9Y9YESKAP03iTYuwVw8LtZNnM2UHZHO9tNj2WJ8,11264
+pyxcp/asamkeydll.exe,sha256=7m3EYufxBx3y-tz_ACPqHnd-vr-Ab8B7JkCHcjf_FPk,11264
 pyxcp/asamkeydll.sh,sha256=DC2NKUMwvi39OQgJ6514Chr4wc1LYbTmQHmMq9jAHHs,59
 pyxcp/checksum.py,sha256=hO2JW_eiO9I0A4eiqovMV9d_y5oidq_w8jKdAE4FeOo,11899
-pyxcp/cmdline.py,sha256=hWVfGIKoM5mM3LGAvYjPip3Otob4_UX6bEnZC2TGi7Q,2385
+pyxcp/cmdline.py,sha256=PltxEwPp6KnXkStI3u3_K9fLNAfCDQauIxMktMzMhxA,2357
 pyxcp/config/__init__.py,sha256=kZ-6hotQYuVa4C6cEGUSqga6CTezKCC2HRa89yVQtXM,48272
 pyxcp/config/legacy.py,sha256=4QdDheX8DbBKv5JVT72_C_cjCgKvZmhN3tJ6hsvBEtI,5220
 pyxcp/constants.py,sha256=9yGfujC0ImTYQWfn41wyw8pluJTSrhMGWIVeIZTgsLg,1160
@@ -26,27 +26,27 @@ pyxcp/cpp_ext/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pyxcp/cpp_ext/aligned_buffer.hpp,sha256=KoUYDjvIJRc2IDOSQXbbSfQ6pdhnBcCi_bxZFC9C6Ko,5448
 pyxcp/cpp_ext/bin.hpp,sha256=WF7ljBEbATQ3wplk7pna4qWtM0MJVHRs5pnILxfkbGU,2673
 pyxcp/cpp_ext/blockmem.hpp,sha256=ysaJwmTWGTfE54Outk3gJYOfAVFd_QaonBMtXLcXwCc,1242
-pyxcp/cpp_ext/cpp_ext.cp310-win_amd64.pyd,sha256=c-m4hker8FJz7HVqYHlcuF44p2vFqUZ2O_yJhpwdXE4,331264
-pyxcp/cpp_ext/cpp_ext.cp311-win_amd64.pyd,sha256=jvtnpYcA8yf-bBEYqDBPIdATsrjKIvJcwIJo-NTPitI,333312
-pyxcp/cpp_ext/cpp_ext.cp312-win_amd64.pyd,sha256=vZghqhyVtUWnc1B0It5JDVKw3l5YLNch85qccetRxMA,337920
-pyxcp/cpp_ext/cpp_ext.cp313-win_amd64.pyd,sha256=SRMCCsDEqgioFKFboI97JaAHxsGKdKA2ZCLZ-V-v1Ho,338432
+pyxcp/cpp_ext/cpp_ext.cp310-win_amd64.pyd,sha256=oxbCxPamWQByLooFc2PAnP_1JVtV-WvsWhNv1g5-kU8,342528
+pyxcp/cpp_ext/cpp_ext.cp311-win_amd64.pyd,sha256=8x-Ymd8Ek7CftpyKM9KWCAETzNz7_8Rh4_wfSOLnVKM,344576
+pyxcp/cpp_ext/cpp_ext.cp312-win_amd64.pyd,sha256=6o16PiwJffaKI_GXaO1zSh4GfcmdCFFsY3vD5nMBuxw,351232
+pyxcp/cpp_ext/cpp_ext.cp313-win_amd64.pyd,sha256=JoCqAjBO2804zgWVwe76RUKbNQY8lre8kgzHGP4Drls,351232
 pyxcp/cpp_ext/daqlist.hpp,sha256=Dv5v9JvaP3Xhe4uTrYfdBsySElIRO50H9Bu4Xl92yfQ,13996
 pyxcp/cpp_ext/event.hpp,sha256=Z-1yxsEKsr81NnLVEWJ2ANA8FV7YsM7EbNxaw-elheE,1200
-pyxcp/cpp_ext/extension_wrapper.cpp,sha256=JIuOYM9DbMQ0iDA1okZGsTKta9cfjOun1zwIyl92Atg,6540
+pyxcp/cpp_ext/extension_wrapper.cpp,sha256=TRrhjinnKkaH9wcY9Tx16kMoVEwSwAFoRVZ2Uot1hao,9852
 pyxcp/cpp_ext/framing.hpp,sha256=8k2juQO0FJvMIiEXjZRMh4CtJdjRBBgH2N3CY57hbyY,11660
 pyxcp/cpp_ext/helper.hpp,sha256=ONAsVupIqqmNDp8bgGWS0TfSYeCFkk3kwwZbbqsh0HQ,7813
 pyxcp/cpp_ext/mcobject.hpp,sha256=t_sjka8_TaWF0EG7mIx8feWAF6uf_CyMtuvCmhE4DB4,6522
 pyxcp/cpp_ext/sxi_framing.hpp,sha256=FvaDOFD5zK8AJUn6yBVoTr-pclstmr478_q_W6COANo,11837
 pyxcp/cpp_ext/tsqueue.hpp,sha256=FWMemzXNgV5dQ7gYmTCzC0QYfgl0VI9JCybYelBcCHU,1026
-pyxcp/daq_stim/__init__.py,sha256=xA12U0QmOBOgDjnel96crCMOKiNNm6TUQcR0Dzxyr1o,13369
+pyxcp/daq_stim/__init__.py,sha256=mWHeLkq9fuoylNypGz_CCKShYN_3c3Su6IEB76Z4U2M,16509
 pyxcp/daq_stim/optimize/__init__.py,sha256=FUWK0GkNpNT-sUlhibp7xa2aSYpm6Flh5yA2w2IOJqg,2520
 pyxcp/daq_stim/optimize/binpacking.py,sha256=RcRTMNmcb5oIAY2G5RHygb_g0GgNf35-cp3utIeUA9w,1257
 pyxcp/daq_stim/scheduler.cpp,sha256=uUR4RUpukE5qZpJNbT_1ARFslAbWupGv0TQJHO_OM0s,1466
 pyxcp/daq_stim/scheduler.hpp,sha256=U_6tUbebmzX5vVZS0EFSgTaPsyxMg6yRXHG_aPWA0x4,1884
-pyxcp/daq_stim/stim.cp310-win_amd64.pyd,sha256=DxyoArqBs2zu1vdLcFWLaL6-K02vvSLjXQL4X33r6Jk,208896
-pyxcp/daq_stim/stim.cp311-win_amd64.pyd,sha256=uFGWZ2Vm5ykPlw1kyVNulAKQvw1VVC75yXkwQXY5YqU,210432
-pyxcp/daq_stim/stim.cp312-win_amd64.pyd,sha256=ZLISu4AoRLTkvhEAMNCU99dGJNfyoI7GxAwCZxpHHVc,214528
-pyxcp/daq_stim/stim.cp313-win_amd64.pyd,sha256=g8JUqjsnGwsR99pAA094BU4o4TDCuPaX4Wwe-PFex3g,214528
+pyxcp/daq_stim/stim.cp310-win_amd64.pyd,sha256=HURS8tDC0S4JggbfuEiTvsGN3Gsgb2tLn_D1DpnyAcA,208896
+pyxcp/daq_stim/stim.cp311-win_amd64.pyd,sha256=eQtJ1HMQ07UJsZHzOZLreonxBg6PUooe3wveagBC_5k,210432
+pyxcp/daq_stim/stim.cp312-win_amd64.pyd,sha256=TsjOX1kV4IGmo33aExy8XMd5irjZqcKYaa-VMP0U8sI,214528
+pyxcp/daq_stim/stim.cp313-win_amd64.pyd,sha256=6z9yU9qUNAq0JboTFnCV3Y-k55lPfmwwEmJH2atFKY0,214528
 pyxcp/daq_stim/stim.cpp,sha256=F2OG67W4KKwTTiUCxm-9egIv3TLFdOkRunX6xf7YOtc,177
 pyxcp/daq_stim/stim.hpp,sha256=U-uInRrA6OCdMl1l1SWbQ_KEPpnNYrWut924IvbW6R0,18508
 pyxcp/daq_stim/stim_wrapper.cpp,sha256=iT2yxJ3LRG7HoYC1bwhM3tCAxF9X_HHierBNsLRmTJg,1995
@@ -69,7 +69,7 @@ pyxcp/examples/xcphello.py,sha256=6hLOzeqPyNERxQn94_Vup87FbGeRjmjPBe4ZLl6tkmU,23
 pyxcp/examples/xcphello_recorder.py,sha256=c7ldGXpjyHe7DCit_S8D5AkqVX81pleLEvLDugcdCeU,3409
 pyxcp/master/__init__.py,sha256=RbMGgWZWRMEpembwgV-kkdSfQxuUZeXsybcspAhMzj0,320
 pyxcp/master/errorhandler.py,sha256=Hyn6geDgrH7EJdpgPWuQYbe_fDOQ2zzYFqRnHFny1Fw,26628
-pyxcp/master/master.py,sha256=UrAczXI6WFP3u6_ilsFmfSjzF44-Mq8UqAGp6f8BE_E,101701
+pyxcp/master/master.py,sha256=DgAUzBo2RnglbUWxdwPGnuJ8mbN1y27vRu0WlewYTrk,101515
 pyxcp/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pyxcp/recorder/.idea/.gitignore,sha256=G_3s42Re2O01YDDyLMIATcP0Af8GCsPSTegRw7zYLhY,184
 pyxcp/recorder/.idea/misc.xml,sha256=XfcpM2YHByf1o3XaftWMr5UIaGSVc9LMzRnZmUp1ynM,142
@@ -99,10 +99,10 @@ pyxcp/recorder/mio.hpp,sha256=5ASJLKSEykH0deAQD5uak-_yAgd5p2n8t06315GSGrg,63346
 pyxcp/recorder/reader.hpp,sha256=ssdaAaG_fHKrJMuMo_tfcCaCjFrIC5HQGNXgR343bVY,5131
 pyxcp/recorder/reco.py,sha256=2CPKxIZNSr6BhjfPrWtxdt81zaJlgU-e73RneG9IsJA,8727
 pyxcp/recorder/recorder.rst,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pyxcp/recorder/rekorder.cp310-win_amd64.pyd,sha256=RVdOvX0n9jxR4OVIagqVoVBCu1fuECmdaXGYA4caTZc,396800
-pyxcp/recorder/rekorder.cp311-win_amd64.pyd,sha256=g8Mk-ZJrT9P1qMUrnkM11Mx-RO5F6ZuqGD3fcsDfY0w,398336
-pyxcp/recorder/rekorder.cp312-win_amd64.pyd,sha256=tEKIMFNX1bv3nMffEwo-CIrMptzqx2jTIMuFuae2ygE,404480
-pyxcp/recorder/rekorder.cp313-win_amd64.pyd,sha256=mFI9_jWq9MsevOsLJBaNe1hV9cGHwMxo8uwcDx-QSOo,404480
+pyxcp/recorder/rekorder.cp310-win_amd64.pyd,sha256=VAcmnVoAKV0U22EpKVWl3j8mIBJ_IKWH-imcfwt_68E,396800
+pyxcp/recorder/rekorder.cp311-win_amd64.pyd,sha256=JCqn8UGpWFbaNvjWDEowiWK2kX8RFvK8-aTntqrofJ0,398336
+pyxcp/recorder/rekorder.cp312-win_amd64.pyd,sha256=LMusSqBjJ14FhuNhDnN-kT3jcxpY_1dvFGTpNSbk6eA,404480
+pyxcp/recorder/rekorder.cp313-win_amd64.pyd,sha256=fmru0QrN9WOdoanDbGVTIzkqv0f6ffgLuWLVI8MTuJQ,404480
 pyxcp/recorder/rekorder.cpp,sha256=U0LMyk8pZXx9emgS_WPVthvn_9IpgE7JGrh4kg-8CX4,1900
 pyxcp/recorder/rekorder.hpp,sha256=sWvRch9bVt6mmgrFHp5mwWhap7HoFG4geeb7UqEIzio,7638
 pyxcp/recorder/setup.py,sha256=_99XFPQAd5V4LcJaSGJwdnbxgxJ7kl8DEXfHsnKO1Yg,998
@@ -112,6 +112,7 @@ pyxcp/recorder/wrap.cpp,sha256=oCsEOnRsvLlaWjyN09X7mcHLzzqCyLskREKb6kmyqNE,8707
 pyxcp/recorder/writer.hpp,sha256=rNjtRTtJes5z-BzKR2K56P_Kvc9MEVQgycu8J0wKf1g,11284
 pyxcp/scripts/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pyxcp/scripts/pyxcp_probe_can_drivers.py,sha256=P_gscDTAofbSVA_Wd1GATrnyWGTf1-Dz_oPdlRFfjuk,567
+pyxcp/scripts/xcp_daq_recorder.py,sha256=Gwg03TWvqZWPSeynHy0pTqoPL6SmTvNpmg1yd-pcus0,1585
 pyxcp/scripts/xcp_examples.py,sha256=q2wNXHVZu4GjcIlZwp2j9Sqm5QH39Olro4BQaLoIqiM,2583
 pyxcp/scripts/xcp_fetch_a2l.py,sha256=mRS42707lEFjH9q9ip2TgIOstc6QBnZ3IMMkf7GtEtk,1239
 pyxcp/scripts/xcp_id_scanner.py,sha256=zsqjEJko8OtzRtHZT6YVVanD7hbaGPv0qsC_jK1Gzig,419
@@ -136,12 +137,12 @@ pyxcp/transport/base.py,sha256=Eb5qLeAP-VXQwHcX2M58Rdl0jZ8K_RFYSoE-Pq6kW64,18784
 pyxcp/transport/base_transport.hpp,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pyxcp/transport/can.py,sha256=JeASLHW2A66Zaq6X5XG9vdfX-eXdhWbttbaMR0Zow20,24032
 pyxcp/transport/eth.py,sha256=8QRzHIQIzzM9T5fbAIMk7FLSQLkMsCJa3UPW_61rXDw,10530
-pyxcp/transport/hdf5_policy.py,sha256=3oLr3nCcm_QshtuDi8oxrbpxaagVo5Xtg8aOFFzMYno,4070
+pyxcp/transport/hdf5_policy.py,sha256=KIewRq5AI-EPNPzw-MHb5lriF-K4Jt5cuaxYFvreonU,5544
 pyxcp/transport/sxi.py,sha256=P3ppV-MzuvLMGPldm8sB_nXKyTCRJeqraQj8yzRwmqI,7379
-pyxcp/transport/transport_ext.cp310-win_amd64.pyd,sha256=GFwxlEB5lQsEh4G_b70I9Y1MqIcTHTkYuQgZYceY4so,386048
-pyxcp/transport/transport_ext.cp311-win_amd64.pyd,sha256=3gzFKFIYa_-1rqhfz-uySR_y6eLett7geYUJy60kBdE,388096
-pyxcp/transport/transport_ext.cp312-win_amd64.pyd,sha256=V6QFS51roQni63rLvzdqRL31o_J5vTOwI6-JUZY2AIE,395776
-pyxcp/transport/transport_ext.cp313-win_amd64.pyd,sha256=UxRDEa9ZFO4hf5RdniTPBMDeF0KhEH1xwAowuZ6zjZQ,396288
+pyxcp/transport/transport_ext.cp310-win_amd64.pyd,sha256=T3jOQqkf_RrbIX1KXuJl2XshwBT0ckZzJMRoMikMfC4,386048
+pyxcp/transport/transport_ext.cp311-win_amd64.pyd,sha256=Lq5_QlaQb0_wjkWVOe7oxdNVlDNeDHdmrpmpi0bb8tc,388096
+pyxcp/transport/transport_ext.cp312-win_amd64.pyd,sha256=pnjkJiLbmrK_rHa67MZnyyBYV5KtORpxBojHz50Q0kE,395776
+pyxcp/transport/transport_ext.cp313-win_amd64.pyd,sha256=XRMdq2FEYFDAFYRO31G1zwtb_mLxdtQZyLAghNonpmM,396288
 pyxcp/transport/transport_ext.hpp,sha256=ABxcvoDPua_IUJ9NhrmxcSoTr3ofLVXlezHtN_bHY5w,6511
 pyxcp/transport/transport_wrapper.cpp,sha256=fJmsiGrH4WZvDri2rJpwTosTHTqlANpWi4kHu7vda8M,12485
 pyxcp/transport/usb_transport.py,sha256=K_tAESxgSVllJinoYanJbFB_j28yOId6m5EgdXvPItQ,8902
@@ -150,8 +151,8 @@ pyxcp/utils/__init__.py,sha256=d4QmrEZiK7xtdCThhZapV2Zbyi0YB_ELNDL49mkji5Y,3509
 pyxcp/utils/cli.py,sha256=BnwQvMk8GERns4B-2I0hDuBk9pE-krc_o36NkBsezB8,3027
 pyxcp/vector/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pyxcp/vector/map.py,sha256=7Gnhvr79geMeqqGVIJPxODXGwABdNDinnqzhpooN5TE,2306
-pyxcp-0.25.4.dist-info/entry_points.txt,sha256=LkHsEwubm30s4oiyCy0cKj6k97ALvQ6KjAVdyEcqu7g,358
-pyxcp-0.25.4.dist-info/licenses/LICENSE,sha256=fTqV5eBpeAZO0_jit8j4Ref9ikBSlHJ8xwj5TLg7gFk,7817
-pyxcp-0.25.4.dist-info/METADATA,sha256=mgeFETPID1gQkYFa5mFKg3wWgu-uZnH4Y7aB2FylsPM,12775
-pyxcp-0.25.4.dist-info/WHEEL,sha256=HCjMoC9qqRBH4O7rtqnFiDpt5hhaxeHHcIYjwJPshyQ,98
-pyxcp-0.25.4.dist-info/RECORD,,
+pyxcp-0.25.8.dist-info/entry_points.txt,sha256=LkHsEwubm30s4oiyCy0cKj6k97ALvQ6KjAVdyEcqu7g,358
+pyxcp-0.25.8.dist-info/licenses/LICENSE,sha256=fTqV5eBpeAZO0_jit8j4Ref9ikBSlHJ8xwj5TLg7gFk,7817
+pyxcp-0.25.8.dist-info/METADATA,sha256=RsFpqcTgWLDZcfvJlhNtnrEZprtf9LSfpJW6FbysG8E,12775
+pyxcp-0.25.8.dist-info/WHEEL,sha256=mbhp6OISYNyQV0z23S-pvC1L-suhijlWHyj3c994WU4,98
+pyxcp-0.25.8.dist-info/RECORD,,

{pyxcp-0.25.4.dist-info → pyxcp-0.25.8.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 2.2.1
+Generator: poetry-core 2.3.0
 Root-Is-Purelib: false
 Tag: cp313-cp313-win_amd64