pyxcp 0.22.25__cp312-cp312-win_amd64.whl → 0.22.26__cp312-cp312-win_amd64.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.22.25"
+__version__ = "0.22.26"

pyxcp/config/__init__.py

@@ -822,9 +822,11 @@ if there is no response to a command.""",
 class General(Configurable):
     """ """
 
-    # loglevel = Unicode("INFO", help="Set the log level by value or name.").tag(config=True)
     disable_error_handling = Bool(False, help="Disable XCP error-handler for performance reasons.").tag(config=True)
     disconnect_response_optional = Bool(False, help="Ignore missing response on DISCONNECT request.").tag(config=True)
+    connect_retries = Integer(help="Number of CONNECT retries (None for infinite retries).", allow_none=True, default_value=3).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)
     seed_n_key_function = Callable(

pyxcp/examples/run_daq.py

@@ -137,8 +137,6 @@ with ap.run(policy=daq_parser) as x:
 
     x.cond_unlock("DAQ")  # DAQ resource is locked in many cases.
 
-    DAQ_LISTS[1].event_num = 0
-
     print("setup DAQ lists.")
     daq_parser.setup()  # Execute setup procedures.
     print("start DAQ lists.")

pyxcp/master/errorhandler.py

@@ -356,6 +356,7 @@ class Executor(SingletonBase):
         self.arguments = arguments
         handler = Handler(inst, func, arguments)
         self.handlerStack.push(handler)
+        connect_retries = inst.config.connect_retries
         try:
             while True:
                 try:
@@ -366,9 +367,14 @@ class Executor(SingletonBase):
                     self.error_code = e.get_error_code()
                     handler.error_code = self.error_code
                 except XcpTimeoutError:
-                    # self.logger.error(f"XcpTimeoutError [{str(e)}]")
+                    is_connect = func.__name__ == "connect"
+                    self.logger.warning(f"XcpTimeoutError -- Service: {func.__name__!r}")
                     self.error_code = XcpError.ERR_TIMEOUT
                     handler.error_code = self.error_code
+                    if is_connect and connect_retries is not None:
+                        if connect_retries == 0:
+                            raise XcpTimeoutError("Maximum CONNECT retries reached.")
+                        connect_retries -= 1
                 except TimeoutError:
                     raise
                 except can.CanError:

pyxcp/recorder/__init__.py

@@ -1,6 +1,7 @@
 #!/usr/bin/env python
 """XCP Frame Recording Facility.
 """
+
 from dataclasses import dataclass
 from typing import Union
 
@@ -16,15 +17,13 @@ else:
 
 from pyxcp.recorder.rekorder import DaqOnlinePolicy  # noqa: F401
 from pyxcp.recorder.rekorder import (
-    DaqRecorderPolicy,
-    Deserializer,
-    MeasurementParameters,
-    ValueHolder,
-    XcpLogFileDecoder,
-    _PyXcpLogFileReader,
-    _PyXcpLogFileWriter,
-    data_types,
+    DaqRecorderPolicy,      # noqa: F401
+    Deserializer,           # noqa: F401
+    MeasurementParameters,  # noqa: F401
+    ValueHolder,            # noqa: F401
 )
+from pyxcp.recorder.rekorder import XcpLogFileDecoder as _XcpLogFileDecoder
+from pyxcp.recorder.rekorder import _PyXcpLogFileReader, _PyXcpLogFileWriter, data_types
 
 
 DATA_TYPES = data_types()

pyxcp/recorder/converter/__init__.py

@@ -1,8 +1,60 @@
+"""Convert pyXCPs .xmraw files to common data formats.
+"""
+
+import csv
 import logging
+import os
+import sqlite3
 from array import array
 from dataclasses import dataclass, field
+from mmap import PAGESIZE
+from pathlib import Path
 from typing import Any, List
 
+import numpy as np
+from rich.logging import RichHandler
+
+
+try:
+    import pyarrow as pa
+    import pyarrow.parquet as pq
+
+    has_arrow = True
+except ImportError:
+    has_arrow = False
+
+try:
+    import h5py
+
+    has_h5py = True
+except ImportError:
+    has_h5py = False
+
+try:
+    from asammdf import MDF, Signal
+    from asammdf.blocks.v4_blocks import HeaderBlock
+    from asammdf.blocks.v4_constants import FLAG_HD_TIME_OFFSET_VALID
+
+    has_asammdf = True
+except ImportError:
+    has_asammdf = False
+
+try:
+    import xlsxwriter
+
+    has_xlsxwriter = True
+
+except ImportError:
+    has_xlsxwriter = False
+
+from pyxcp import console
+from pyxcp.recorder.rekorder import XcpLogFileDecoder as _XcpLogFileDecoder
+
+
+FORMAT = "%(message)s"
+logging.basicConfig(level="NOTSET", format=FORMAT, datefmt="[%X]", handlers=[RichHandler()])
+
+log = logging.getLogger("rich")
 
 MAP_TO_ARRAY = {
     "U8": "B",
@@ -19,13 +71,26 @@ MAP_TO_ARRAY = {
     "BF16": "f",
 }
 
-logger = logging.getLogger("PyXCP")
+MAP_TO_NP = {
+    "U8": np.uint8,
+    "I8": np.int8,
+    "U16": np.uint16,
+    "I16": np.int16,
+    "U32": np.uint32,
+    "I32": np.int32,
+    "U64": np.uint64,
+    "I64": np.int64,
+    "F32": np.float32,
+    "F64": np.float64,
+    "F16": np.float16,
+    "BF16": np.float16,
+}
 
 
 @dataclass
 class Storage:
     name: str
-    arrow_type: Any
+    target_type: Any
     arr: array
 
 
@@ -35,3 +100,352 @@ class StorageContainer:
     arr: List[Storage] = field(default_factory=[])
     ts0: List[int] = field(default_factory=lambda: array("Q"))
     ts1: List[int] = field(default_factory=lambda: array("Q"))
+
+
+class XcpLogFileDecoder(_XcpLogFileDecoder):
+    """"""
+
+    def __init__(
+        self,
+        recording_file_name: str,
+        out_file_suffix: str,
+        remove_file: bool = True,
+        target_type_map: dict = None,
+        target_file_name: str = "",
+    ):
+        super().__init__(recording_file_name)
+        self.logger = logging.getLogger("PyXCP")
+        self.logger.setLevel(logging.DEBUG)
+        self.out_file_name = Path(recording_file_name).with_suffix(out_file_suffix)
+        self.out_file_suffix = out_file_suffix
+        self.target_type_map = target_type_map or {}
+        if remove_file:
+            try:
+                os.unlink(self.out_file_name)
+            except FileNotFoundError:
+                pass
+
+    def initialize(self) -> None:
+        self.on_initialize()
+
+    def on_initialize(self) -> None:
+        self.setup_containers()
+
+    def finalize(self) -> None:
+        self.on_finalize()
+
+    def on_finalize(self) -> None:
+        pass
+
+    def setup_containers(self) -> None:
+        self.tables = []
+        for dl in self.daq_lists:
+            result = []
+            for name, type_str in dl.headers:
+                array_txpe = MAP_TO_ARRAY[type_str]
+                target_type = self.target_type_map.get(type_str)
+                sd = Storage(name, target_type, array(array_txpe))
+                result.append(sd)
+            sc = StorageContainer(dl.name, result)
+            self.tables.append(sc)
+            self.on_container(sc)
+
+    def on_container(self, sc: StorageContainer) -> None:
+        pass
+
+
+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.ts0.append(timestamp0)
+        storage_container.ts1.append(timestamp1)
+        for idx, elem in enumerate(measurements):
+            storage = storage_container.arr[idx]
+            storage.arr.append(elem)
+
+
+class ArrowConverter(CollectRows, XcpLogFileDecoder):
+    """"""
+
+    MAP_TO_ARROW = {
+        "U8": pa.uint8(),
+        "I8": pa.int8(),
+        "U16": pa.uint16(),
+        "I16": pa.int16(),
+        "U32": pa.uint32(),
+        "I32": pa.int32(),
+        "U64": pa.uint64(),
+        "I64": pa.int64(),
+        "F32": pa.float32(),
+        "F64": pa.float64(),
+        "F16": pa.float16(),
+        "BF16": pa.float16(),
+    }
+
+    def __init__(self, recording_file_name: str, target_file_name: str = ""):
+        super().__init__(
+            recording_file_name=recording_file_name,
+            out_file_suffix=".parquet",
+            remove_file=False,
+            target_type_map=self.MAP_TO_ARROW,
+            target_file_name=target_file_name,
+        )
+
+    def on_initialize(self) -> None:
+        super().on_initialize()
+
+    def on_finalize(self) -> None:
+        result = []
+        for arr in self.tables:
+            timestamp0 = arr.ts0
+            timestamp1 = arr.ts1
+            names = ["timestamp0", "timestamp1"]
+            data = [timestamp0, timestamp1]
+            for sd in arr.arr:
+                adt = pa.array(sd.arr, type=sd.target_type)
+                names.append(sd.name)
+                data.append(adt)
+            table = pa.Table.from_arrays(data, names=names)
+            fname = f"{arr.name}{self.out_file_suffix}"
+            self.logger.info(f"Writing file {fname!r}")
+            pq.write_table(table, fname)
+            result.append(table)
+        return result
+
+
+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
+        )
+
+    def on_initialize(self) -> None:
+        self.csv_writers = []
+        super().on_initialize()
+
+    def on_container(self, sc: StorageContainer) -> None:
+        fname = f"{sc.name}{self.out_file_suffix}"
+        self.logger.info(f"Creating file {fname!r}.")
+        writer = csv.writer(open(fname, "w", newline=""), dialect="excel")
+        headers = ["ts0", "ts1"] + [e.name for e in sc.arr]
+        writer.writerow(headers)
+        self.csv_writers.append(writer)
+
+    def on_finalize(self) -> None:
+        self.logger.info("Done.")
+
+    def on_daq_list(self, daq_list_num: int, timestamp0: int, timestamp1: int, measurements: list) -> None:
+        writer = self.csv_writers[daq_list_num]
+        data = [timestamp0, timestamp1, *measurements]
+        writer.writerow(data)
+
+
+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)
+
+    def on_initialize(self) -> None:
+        self.logger.info(f"Creating file {str(self.out_file_name)!r}.")
+        self.xls_workbook = xlsxwriter.Workbook(self.out_file_name)
+        self.xls_sheets = []
+        self.rows = []
+        super().on_initialize()
+
+    def on_container(self, sc: StorageContainer) -> None:
+        sheet = self.xls_workbook.add_worksheet(sc.name)
+        self.xls_sheets.append(sheet)
+        headers = ["ts0", "ts1"] + [e.name for e in sc.arr]
+        sheet.write_row(0, 0, headers)
+        self.rows.append(1)
+
+    def on_finalize(self) -> None:
+        self.xls_workbook.close()
+        self.logger.info("Done.")
+
+    def on_daq_list(self, daq_list_num: int, timestamp0: int, timestamp1: int, measurements: list) -> None:
+        sheet = self.xls_sheets[daq_list_num]
+        row = self.rows[daq_list_num]
+        data = [timestamp0, timestamp1] + measurements
+        sheet.write_row(row, 0, data)
+        self.rows[daq_list_num] += 1
+
+
+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)
+
+    def on_initialize(self) -> None:
+        self.logger.info(f"Creating file {str(self.out_file_name)!r}")
+        self.out_file = h5py.File(self.out_file_name, "w")
+        super().on_initialize()
+
+    def on_finalize(self) -> None:
+        for arr in self.tables:
+            timestamp0 = arr.ts0
+            timestamp1 = arr.ts1
+            self.out_file[f"/{arr.name}/timestamp0"] = timestamp0
+            self.out_file[f"/{arr.name}/timestamp1"] = timestamp1
+            for sd in arr.arr:
+                self.out_file[f"/{arr.name}/{sd.name}"] = sd.arr
+            self.logger.info(f"Writing table {arr.name!r}")
+            self.logger.info("Done.")
+        self.out_file.close()
+
+
+class MdfConverter(CollectRows, XcpLogFileDecoder):
+
+    def __init__(self, recording_file_name: str, target_file_name: str = ""):
+        super().__init__(
+            recording_file_name=recording_file_name,
+            out_file_suffix=".mf4",
+            target_type_map=MAP_TO_NP,
+            target_file_name=target_file_name,
+        )
+
+    def on_initialize(self) -> None:
+        super().on_initialize()
+
+    def on_finalize(self) -> None:
+        timestamp_info = self.parameters.timestamp_info
+        hdr = HeaderBlock(
+            abs_time=timestamp_info.timestamp_ns,
+            tz_offset=timestamp_info.utc_offset,
+            daylight_save_time=timestamp_info.dst_offset,
+            time_flags=FLAG_HD_TIME_OFFSET_VALID,
+        )
+        hdr.comment = f"""<HDcomment><TX>Timezone: {timestamp_info.timezone}</TX></HDcomment>"""  # Test-Comment.
+        mdf4 = MDF(version="4.10")
+        mdf4.header = hdr
+        for idx, arr in enumerate(self.tables):
+            signals = []
+            timestamps = arr.ts0
+            for sd in arr.arr:
+                signal = Signal(samples=sd.arr, name=sd.name, timestamps=timestamps)
+                signals.append(signal)
+            self.logger.info(f"Appending data-group {arr.name!r}")
+            mdf4.append(signals, acq_name=arr.name, comment="Created by pyXCP recorder")
+        self.logger.info(f"Writing {str(self.out_file_name)!r}")
+        mdf4.save(self.out_file_name, compression=2, overwrite=True)
+        self.logger.info("Done.")
+
+
+class SqliteConverter(XcpLogFileDecoder):
+    """ """
+
+    MAP_TO_SQL = {
+        "U8": "INTEGER",
+        "I8": "INTEGER",
+        "U16": "INTEGER",
+        "I16": "INTEGER",
+        "U32": "INTEGER",
+        "I32": "INTEGER",
+        "U64": "INTEGER",
+        "I64": "INTEGER",
+        "F32": "FLOAT",
+        "F64": "FLOAT",
+        "F16": "FLOAT",
+        "BF16": "FLOAT",
+    }
+
+    def __init__(self, recording_file_name: str, target_file_name: str = ""):
+        super().__init__(
+            recording_file_name=recording_file_name,
+            out_file_suffix=".sq3",
+            target_type_map=self.MAP_TO_SQL,
+            target_file_name=target_file_name,
+        )
+
+    def on_initialize(self) -> None:
+        self.logger.info(f"Creating database {str(self.out_file_name)!r}.")
+        self.create_database(self.out_file_name)
+        self.insert_stmt = {}
+        super().on_initialize()
+
+    def on_container(self, sc: StorageContainer) -> None:
+        self.create_table(sc)
+        self.logger.info(f"Creating table {sc.name!r}.")
+        self.insert_stmt[sc.name] = (
+            f"""INSERT INTO {sc.name}({', '.join(['ts0', 'ts1'] + [r.name for r in sc.arr])}) VALUES({', '.join(["?" for _ in range(len(sc.arr) + 2)])})"""
+        )
+
+    def on_finalize(self) -> None:
+        self.conn.commit()
+        self.conn.close()
+        print("Done.")
+
+    def on_daq_list(self, daq_list_num: int, timestamp0: int, timestamp1: int, measurements: list) -> None:
+        sc = self.tables[daq_list_num]
+        insert_stmt = self.insert_stmt[sc.name]
+        data = [timestamp0, timestamp1, *measurements]
+        self.execute(insert_stmt, data)
+
+    def create_database(self, db_name: str) -> None:
+        self.conn = sqlite3.Connection(db_name)
+        self.cursor = self.conn.cursor()
+        self.execute("PRAGMA FOREIGN_KEYS=ON")
+        self.execute(f"PRAGMA PAGE_SIZE={PAGESIZE}")
+        self.execute("PRAGMA SYNCHRONOUS=OFF")
+        self.execute("PRAGMA LOCKING_MODE=EXCLUSIVE")
+        self.execute("PRAGMA TEMP_STORE=MEMORY")
+
+        timestamp_info = self.parameters.timestamp_info
+        self.execute(
+            "CREATE TABLE timestamp_info(timestamp_ns INTEGER, utc_offset INTEGER, dst_offset INTEGER, timezone VARCHAR(255))"
+        )
+        self.execute("CREATE TABLE table_names(name VARCHAR(255))")
+        self.execute(
+            "INSERT INTO timestamp_info VALUES(?, ?, ?, ?)",
+            [timestamp_info.timestamp_ns, timestamp_info.utc_offset, timestamp_info.dst_offset, timestamp_info.timezone],
+        )
+
+    def create_table(self, sc: StorageContainer) -> None:
+        columns = ["ts0 INTEGER", "ts1 INTEGER"]
+        for elem in sc.arr:
+            columns.append(f"{elem.name} {elem.target_type}")
+        ddl = f"CREATE TABLE {sc.name}({', '.join(columns)})"
+        self.execute(ddl)
+        self.execute("INSERT INTO table_names VALUES(?)", [sc.name])
+
+    def execute(self, *args: List[str]) -> None:
+        try:
+            self.cursor.execute(*args)
+        except Exception as e:
+            print(e)
+
+
+CONVERTERS = {
+    "arrow": ArrowConverter,
+    "csv": CsvConverter,
+    "excel": ExcelConverter,
+    "hdf5": HdfConverter,
+    "mdf": MdfConverter,
+    "sqlite3": SqliteConverter,
+}
+
+CONVERTER_REQUIREMENTS = {
+    "arrow": (has_arrow, "pyarrow"),
+    "csv": (True, "csv"),
+    "excel": (has_xlsxwriter, "xlsxwriter"),
+    "hdf5": (has_h5py, "h5py"),
+    "mdf": (has_asammdf, "asammdf"),
+    "sqlite3": (True, "csv"),
+}
+
+
+def convert_xmraw(converter_name: str, recording_file_name: str, target_file_name: str, *args, **kwargs) -> None:
+    converter_class = CONVERTERS.get(converter_name.lower())
+    if converter_class is None:
+        console.print(f"Invalid converter name: {converter_name!r}")
+        return
+    available, pck_name = CONVERTER_REQUIREMENTS.get(converter_name.lower(), (True, ""))
+    if not available:
+        console.print(f"Converter {converter_name!r} requires package {pck_name!r}.")
+        console.print(f"Please run [green]pip install {pck_name}[/green] to install it.")
+        return
+    # Path(*p.parts[:-1], p.stem)
+    converter = converter_class(recording_file_name)
+    converter.run()

pyxcp/types.py

@@ -491,9 +491,15 @@ SetCalPageMode = BitStruct(
     "ecu" / Flag,
 )
 
+PagProperties = BitStruct(
+    Padding(7),
+    "freezeSupported" / Flag,
+)
+
+
 GetPagProcessorInfoResponse = Struct(
     "maxSegments" / Int8ul,
-    "pagProperties" / Int8ul,
+    "pagProperties" / PagProperties,
 )
 
 GetSegmentInfoMode0Response = Struct(

{pyxcp-0.22.25.dist-info → pyxcp-0.22.26.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: pyxcp
-Version: 0.22.25
+Version: 0.22.26
 Summary: Universal Calibration Protocol for Python
 License: LGPLv3
 Keywords: automotive,ecu,xcp,asam,autosar

{pyxcp-0.22.25.dist-info → pyxcp-0.22.26.dist-info}/RECORD

@@ -1,4 +1,4 @@
-pyxcp/__init__.py,sha256=NDu785DrhpFkKcUgVKRBeBhp6NC9yp9DVxG_MGx_3Dg,548
+pyxcp/__init__.py,sha256=RJc-8q7P408Jmlwt5OMDoDop9h53YvraQnGC0mdVmtY,548
 pyxcp/aml/EtasCANMonitoring.a2l,sha256=EJYwe3Z3H24vyWAa6lUgcdKnQY8pwFxjyCN6ZU1ST8w,1509
 pyxcp/aml/EtasCANMonitoring.aml,sha256=xl0DdyeiIaLW0mmmJNAyJS0CQdOLSxt9dxfgrdSlU8Y,2405
 pyxcp/aml/ifdata_CAN.a2l,sha256=NCUnCUEEgRbZYSLGtUGwL2e7zJ8hrp0SbmLHGv8uY58,612
@@ -18,17 +18,17 @@ pyxcp/asamkeydll.c,sha256=dVEvU0S1kgIo62S0La-T8xHSw668LM_DYc_fiQ0No6g,2952
 pyxcp/asamkeydll.sh,sha256=DC2NKUMwvi39OQgJ6514Chr4wc1LYbTmQHmMq9jAHHs,59
 pyxcp/checksum.py,sha256=alze1JiZ2JmdRul9QzP_-fuAqJcNyYBbo35zBwEKqHk,11535
 pyxcp/cmdline.py,sha256=na3ZbWQ-5ezsi1MrkuxMTCAXonUF3X6-LutoneyE3dU,1529
-pyxcp/config/__init__.py,sha256=u9v-eUAJd8amEvkJsns5DCMhvYD3Lp3Ct0posmuqOec,41635
+pyxcp/config/__init__.py,sha256=nToBy_zPFQZmCUgRZ1RUjlw-OulCcvoFuGFvPw242z8,41701
 pyxcp/config/legacy.py,sha256=4QdDheX8DbBKv5JVT72_C_cjCgKvZmhN3tJ6hsvBEtI,5220
 pyxcp/constants.py,sha256=9yGfujC0ImTYQWfn41wyw8pluJTSrhMGWIVeIZTgsLg,1160
 pyxcp/cpp_ext/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pyxcp/cpp_ext/bin.hpp,sha256=PwJloZek21la-RBSda2Hc0u_6gID0sfTduPeplaAyR4,2561
 pyxcp/cpp_ext/blockmem.hpp,sha256=ysaJwmTWGTfE54Outk3gJYOfAVFd_QaonBMtXLcXwCc,1242
-pyxcp/cpp_ext/cpp_ext.cp310-win_amd64.pyd,sha256=VWNTkyiub_-mX4OXAsEROyUfJz3fOSuyz_clzlwaYTo,279552
-pyxcp/cpp_ext/cpp_ext.cp311-win_amd64.pyd,sha256=2iSOT9Ulo4unK1j9kVlUw6RXxqxgcVrCgEYo3aXNPRM,281600
-pyxcp/cpp_ext/cpp_ext.cp312-win_amd64.pyd,sha256=LKQ6C5uI4Nc9ccjht56ZS3mA-9zL8TYRJ-TCLp9An18,285696
-pyxcp/cpp_ext/cpp_ext.cp38-win_amd64.pyd,sha256=FvxLTjwiAyCQBEoqKOZ-fci6t1caxfVchOpwv7ruPzY,279552
-pyxcp/cpp_ext/cpp_ext.cp39-win_amd64.pyd,sha256=Jx5MDTdx6bNKSEvJjd_Wa-TnVHmexbmdjPqQARmVYx8,260096
+pyxcp/cpp_ext/cpp_ext.cp310-win_amd64.pyd,sha256=6QbsSXVMsmE8L8Uo3JIojb_U9EOrdJc-MZk-2GI3Y5c,279552
+pyxcp/cpp_ext/cpp_ext.cp311-win_amd64.pyd,sha256=BD3qqAHgl5HJP--VT_C5fbtSODPobAGd1ks0co8kq9E,281600
+pyxcp/cpp_ext/cpp_ext.cp312-win_amd64.pyd,sha256=XhGYmwgFsebGsoIgPLJlRd9Mls0RfSZ9tOKXSSEHBLE,285696
+pyxcp/cpp_ext/cpp_ext.cp38-win_amd64.pyd,sha256=dAWWWsucJ22tqPC_06-Kr6nhz5nNe4m6YYeMhh384AY,279552
+pyxcp/cpp_ext/cpp_ext.cp39-win_amd64.pyd,sha256=te0D-4CZw619YbwRrIxS8jmdS_UcPS2gQPCSb0Jx8Vg,260096
 pyxcp/cpp_ext/daqlist.hpp,sha256=g2hlxgoQorAGKHedZFZ0c2FQh1APMIA9sVB6M6hD_n8,7277
 pyxcp/cpp_ext/event.hpp,sha256=Z-1yxsEKsr81NnLVEWJ2ANA8FV7YsM7EbNxaw-elheE,1200
 pyxcp/cpp_ext/extension_wrapper.cpp,sha256=FXFjyruBjQYqjCYZZcajdYv6dvNnCggMAbWLqJmfuTM,4756
@@ -40,11 +40,11 @@ pyxcp/daq_stim/optimize/__init__.py,sha256=FUWK0GkNpNT-sUlhibp7xa2aSYpm6Flh5yA2w
 pyxcp/daq_stim/optimize/binpacking.py,sha256=Iltho5diKlJG-ltbmx053U2vOFRlCISolXK61T14l_I,1257
 pyxcp/daq_stim/scheduler.cpp,sha256=a7VK7kP2Hs8yMlcDAkXwJ0bH88lr_yz156sphcHS7Z4,715
 pyxcp/daq_stim/scheduler.hpp,sha256=U_6tUbebmzX5vVZS0EFSgTaPsyxMg6yRXHG_aPWA0x4,1884
-pyxcp/daq_stim/stim.cp310-win_amd64.pyd,sha256=DD7ufKxaaRW5DmBBsAe4whg6qoi8GQ62VT7IS7U8KlA,189440
-pyxcp/daq_stim/stim.cp311-win_amd64.pyd,sha256=5HWuBjjAG1IaP90UK3IeOMkBADYyCMMa_U9QyuPQxrk,192000
-pyxcp/daq_stim/stim.cp312-win_amd64.pyd,sha256=-LlfCB7oJoIOXTefEHFIwSTVgLLLnR-3JVSP2XLpop0,193536
-pyxcp/daq_stim/stim.cp38-win_amd64.pyd,sha256=X_ftCGxwZ4slT40A21gSUwJq8J-vB8Q_VUvZgQkRB2c,189440
-pyxcp/daq_stim/stim.cp39-win_amd64.pyd,sha256=nM37yO0Em1w_FxpT4mL5a8IVkYT5wsKLON1b1lI6C6w,183296
+pyxcp/daq_stim/stim.cp310-win_amd64.pyd,sha256=Ipaa8gxNZetfWUs8SHP-uQ-3bQ6aJzv7queAOKmcZBA,189440
+pyxcp/daq_stim/stim.cp311-win_amd64.pyd,sha256=PeX2RT5L-kBqyfvg3AazPSrD1Fd93K9b1hB8fVzzTns,192000
+pyxcp/daq_stim/stim.cp312-win_amd64.pyd,sha256=V1Zj_B8HRGVNOK7VvQ7A8FXao1pLZdJ68FAb2mZlQWA,193536
+pyxcp/daq_stim/stim.cp38-win_amd64.pyd,sha256=Sh3DMZHjlD4EOKom7gyLPp2yMyIcVZK02msoFsFdCrg,189440
+pyxcp/daq_stim/stim.cp39-win_amd64.pyd,sha256=cfMM0LKRqcjWx-I0ijRk85aN9YEPlsToeNJU-dLBMec,183296
 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
@@ -59,12 +59,7 @@ pyxcp/examples/conf_nixnet.json,sha256=BvXPrljPGzaRTNPch3K0XfU3KSBP1sVDDNP7yY850
 pyxcp/examples/conf_socket_can.toml,sha256=gTacQGm0p6fhPCMWC3ScLq9Xj-xJmNbjNXkjO4o7r8k,269
 pyxcp/examples/conf_sxi.json,sha256=cXwNGoOpvqhdjXBQcE8lKgTs50wi9beosWKskZGJ-nI,158
 pyxcp/examples/conf_sxi.toml,sha256=t-XsgRljcMdj0f3_CGRT60c77LeQPNbjIT17YxDK3Yg,125
-pyxcp/examples/ex_arrow.py,sha256=HvY5Lc7rL87-FgTTcZSQJLjSiTdfjfjMLu0mMmLpW10,3020
-pyxcp/examples/ex_csv.py,sha256=GNWQ3IatXj3Kg5MUX6p8tzJRUppGreON9dkrNiqdTtk,2461
-pyxcp/examples/ex_excel.py,sha256=VpoqRTv-rHz-MnaFKt5f7MqDrK9OLYyRJvVWzCFsayc,2828
-pyxcp/examples/ex_mdf.py,sha256=zfivlNkbbsfvwqsISttaoQk1R888r7UUtwSqocE60sU,3759
-pyxcp/examples/ex_sqlite.py,sha256=ludD0EIziBhBNnC3MOrQTGs06cl7iNyL2yefwe53zNc,4268
-pyxcp/examples/run_daq.py,sha256=KXL9myK3w7RCIgjZblU2i1XOP5l4V0YRQKNRXF7ISIo,5518
+pyxcp/examples/run_daq.py,sha256=gSKkJ_S4QgP6Pgeu-gNoh_hGzxtrAgcbQ1AEEC2QWHE,5484
 pyxcp/examples/xcp_policy.py,sha256=io9tS2W-7PvR8ZzU203KolFrDp67eorUlwNWvA4kC5k,1921
 pyxcp/examples/xcp_read_benchmark.py,sha256=zOG0Yrji10vA0vhHa27KK7zgc3JDpzXzXsFnIU4C_AM,956
 pyxcp/examples/xcp_skel.py,sha256=YXLQC8nn8aAwYSVuBGhr1dvmdMBjmO1Ee1w3e5sy16s,1159
@@ -73,16 +68,16 @@ pyxcp/examples/xcp_user_supplied_driver.py,sha256=bL-6HDvPjgRErvYVdaRL_Pg1GDxu02
 pyxcp/examples/xcphello.py,sha256=xbcWq8StRJyUZBLUvknsXv7VkEBD5SU0SJjlZTHsSzs,2630
 pyxcp/examples/xcphello_recorder.py,sha256=QHWJsq5h5CI9t5qEmMSorZyzirTpoXz4nzuKTMzbZCA,3409
 pyxcp/master/__init__.py,sha256=QQbkUJM1WQ-5p2MiNFYxLAmHhNsCQLzDp-S4aoOFxoA,318
-pyxcp/master/errorhandler.py,sha256=U5QuvGRDM9kRNwY5kbkTOnthp19RHoXEGCsaBNiFTps,14973
+pyxcp/master/errorhandler.py,sha256=ulL6WiraZbVZnM2pfR8S9vlWAAP5UXwXqmbjjxH9rgc,15359
 pyxcp/master/master.py,sha256=y5i5HTw5g4HKHW8tXfpNc0hmaQjle-3dsUkVFqPjUXc,78365
 pyxcp/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pyxcp/recorder/__init__.py,sha256=pg-cdOaoj-D-woFxFb2p6SpFTNTdpQEIknHdDaQ9ROE,2695
+pyxcp/recorder/__init__.py,sha256=jeTmKvfjIenxHxt7zn6HMjnDpuPQU0d9SdnYK_t3gdE,2850
 pyxcp/recorder/build_clang.cmd,sha256=JvFngSnb28XcBGXxC6MGrcOCGYfahOIvHpgRpqbA6HQ,175
 pyxcp/recorder/build_clang.sh,sha256=zmU3nZxaNH1pxGWMyQ-S541TuVqxS00p3iPR9NUP4Ec,181
 pyxcp/recorder/build_gcc.cmd,sha256=zj732DdvqDzGAFg7dvF83DUpf8Qf6rQ0cqEaID15Z80,238
 pyxcp/recorder/build_gcc.sh,sha256=nCSh7G8xtxWtDNrMqNUxcjnm_CFpMeduIF0X-RSJtHA,211
 pyxcp/recorder/build_gcc_arm.sh,sha256=jEo6Mgt_aVDL3nHtffecXOrN6gRsEoaA3S4pPrAzpCE,240
-pyxcp/recorder/converter/__init__.py,sha256=avxsOiQJ-zrmQaS7qocp5yebAD-b5Lq4ehOzISUJuFw,700
+pyxcp/recorder/converter/__init__.py,sha256=7gP3JmI5aPjVcoVqO7EqwdDKqzzidytH8a8pPKyRvAU,14779
 pyxcp/recorder/lz4.c,sha256=rOy3JE2SsOXvJ8a9pgGEfGpbDJnJR03dSVej0CwPmjg,120974
 pyxcp/recorder/lz4.h,sha256=Kz_2V6kvOunNHoPl9-EqxWDVCvYXbU0J-pkSnCeXubs,46483
 pyxcp/recorder/lz4hc.c,sha256=E56iE5CQ6fhQIVi3qNpxiIIP2sTGeC80JtVPyhidV6Q,88870
@@ -91,11 +86,11 @@ pyxcp/recorder/mio.hpp,sha256=5ASJLKSEykH0deAQD5uak-_yAgd5p2n8t06315GSGrg,63346
 pyxcp/recorder/reader.hpp,sha256=rr9XZ_ciL6eF2_xEqyt9XYNqTIze9ytAsnf8uYukO9U,5201
 pyxcp/recorder/reco.py,sha256=6N6FIwfCEVMpi5dr3eUOQa1lowcg2LCnS_sy_-b-UiQ,8725
 pyxcp/recorder/recorder.rst,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pyxcp/recorder/rekorder.cp310-win_amd64.pyd,sha256=CGdvShmnyjesXbPTQ8rM_bqpftDtXRZ1A7NjsGhkrDc,377856
-pyxcp/recorder/rekorder.cp311-win_amd64.pyd,sha256=_OCKW_sm_heL1rvvMqM3HiAb8oH9on2lvy42vroQFcM,380416
-pyxcp/recorder/rekorder.cp312-win_amd64.pyd,sha256=OVrH53mF32JztlRAIJAXYRL1FRWuUJjr0Z3IwrwnWDM,382976
-pyxcp/recorder/rekorder.cp38-win_amd64.pyd,sha256=_XW8GKdICxi0mzTRHwZ7Fc_afbCMOPrCQpNa-EozKnE,377856
-pyxcp/recorder/rekorder.cp39-win_amd64.pyd,sha256=IlUPHXqh86T7fBmgHC8EE7nTMuCkJMYTggM9u52LSwU,364032
+pyxcp/recorder/rekorder.cp310-win_amd64.pyd,sha256=kdZ8tFAEG6DYBZhh6gq353ciHfADV_tr-4xODSm0Xtw,377856
+pyxcp/recorder/rekorder.cp311-win_amd64.pyd,sha256=KY_0mU2ZWOtaTZohpLAlXPOBQ5ueyXlkDCqrh1Gjcwo,380416
+pyxcp/recorder/rekorder.cp312-win_amd64.pyd,sha256=1G6rlgiKpjBNf5_Ipt7xsvDPrOZc2ErOiGu0Vd-Syj4,382976
+pyxcp/recorder/rekorder.cp38-win_amd64.pyd,sha256=QXsP963LBZg8uxjZqmFgxBlxxjFKiKKrvja-v7asr1c,377856
+pyxcp/recorder/rekorder.cp39-win_amd64.pyd,sha256=MHWy_5Em0uDyGq39Rt3kmwMZRG9qYwcGN5tWug_i-Js,364032
 pyxcp/recorder/rekorder.cpp,sha256=U0LMyk8pZXx9emgS_WPVthvn_9IpgE7JGrh4kg-8CX4,1900
 pyxcp/recorder/rekorder.hpp,sha256=sWvRch9bVt6mmgrFHp5mwWhap7HoFG4geeb7UqEIzio,7638
 pyxcp/recorder/setup.py,sha256=_99XFPQAd5V4LcJaSGJwdnbxgxJ7kl8DEXfHsnKO1Yg,998
@@ -129,12 +124,12 @@ pyxcp/transport/eth.py,sha256=xPzN2oSALoPKJVvZpBljPSV1AxfpjRusOzymO-TD1Rw,8711
 pyxcp/transport/sxi.py,sha256=vM8WZIKuu_dNuqkxZM_1n6iQkQCCzo4ykWpiG6ba8Fk,4695
 pyxcp/transport/transport_wrapper.cpp,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pyxcp/transport/usb_transport.py,sha256=JuYrwkWsUdibdVNA57LBEQT3a3ykOgWPdWcfqj96nDE,8343
-pyxcp/types.py,sha256=wm3tOocuAln4jpH_mDguPRYtIzHSQ_KQBYNATFB2WXc,26068
+pyxcp/types.py,sha256=mjp3FhsTTbS3D5VuC-dfdbMql0lJwEfbZjf8a2pHi1o,26158
 pyxcp/utils.py,sha256=unlg0CoNwcWYfd-BE0hZJ93uhlAoW_nryv9tS_R3C44,2969
 pyxcp/vector/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pyxcp/vector/map.py,sha256=7Gnhvr79geMeqqGVIJPxODXGwABdNDinnqzhpooN5TE,2306
-pyxcp-0.22.25.dist-info/entry_points.txt,sha256=2JbL-pWn9UxpBrS64aWiFFkq9x2A7y-dkrxYlfQqIJU,307
-pyxcp-0.22.25.dist-info/LICENSE,sha256=fTqV5eBpeAZO0_jit8j4Ref9ikBSlHJ8xwj5TLg7gFk,7817
-pyxcp-0.22.25.dist-info/METADATA,sha256=oUrQTmW0BB6APl8u-j-RKbfm75jwXGBVnr72VmiaOjo,4088
-pyxcp-0.22.25.dist-info/WHEEL,sha256=cnXks5W6K-GKE7eq3gbNbzgMUdWLplnoIULPQiXHuZs,98
-pyxcp-0.22.25.dist-info/RECORD,,
+pyxcp-0.22.26.dist-info/entry_points.txt,sha256=2JbL-pWn9UxpBrS64aWiFFkq9x2A7y-dkrxYlfQqIJU,307
+pyxcp-0.22.26.dist-info/LICENSE,sha256=fTqV5eBpeAZO0_jit8j4Ref9ikBSlHJ8xwj5TLg7gFk,7817
+pyxcp-0.22.26.dist-info/METADATA,sha256=_lhdH3MGmewLKRJk-lBDNRuqSu2n9VJs_hbwWsuSUD8,4088
+pyxcp-0.22.26.dist-info/WHEEL,sha256=cnXks5W6K-GKE7eq3gbNbzgMUdWLplnoIULPQiXHuZs,98
+pyxcp-0.22.26.dist-info/RECORD,,

pyxcp/examples/ex_arrow.py

@@ -1,109 +0,0 @@
-import argparse
-import logging
-from array import array
-from dataclasses import dataclass, field
-from typing import Any, List
-
-import pyarrow as pa
-import pyarrow.parquet as pq
-
-from pyxcp.recorder import XcpLogFileDecoder
-
-
-MAP_TO_ARROW = {
-    "U8": pa.uint8(),
-    "I8": pa.int8(),
-    "U16": pa.uint16(),
-    "I16": pa.int16(),
-    "U32": pa.uint32(),
-    "I32": pa.int32(),
-    "U64": pa.uint64(),
-    "I64": pa.int64(),
-    "F32": pa.float32(),
-    "F64": pa.float64(),
-    "F16": pa.float16(),
-    "BF16": pa.float16(),
-}
-
-MAP_TO_ARRAY = {
-    "U8": "B",
-    "I8": "b",
-    "U16": "H",
-    "I16": "h",
-    "U32": "L",
-    "I32": "l",
-    "U64": "Q",
-    "I64": "q",
-    "F32": "f",
-    "F64": "d",
-    "F16": "f",
-    "BF16": "f",
-}
-
-logger = logging.getLogger("PyXCP")
-
-parser = argparse.ArgumentParser(description="Use .xmraw files in an Apache Arrow application.")
-parser.add_argument("xmraw_file", help=".xmraw file")
-args = parser.parse_args()
-
-
-@dataclass
-class Storage:
-    name: str
-    arrow_type: Any
-    arr: array
-
-
-@dataclass
-class StorageContainer:
-    name: str
-    arr: List[Storage] = field(default_factory=[])
-    ts0: List[int] = field(default_factory=lambda: array("Q"))
-    ts1: List[int] = field(default_factory=lambda: array("Q"))
-
-
-class Decoder(XcpLogFileDecoder):
-
-    def initialize(self) -> None:
-        self.arrow_tables = []
-        for dl in self.daq_lists:
-            result = []
-            for name, type_str in dl.headers:
-                array_txpe = MAP_TO_ARRAY[type_str]
-                arrow_type = MAP_TO_ARROW[type_str]
-                sd = Storage(name, arrow_type, array(array_txpe))
-                print(f"\t{name!r} {array_txpe} {arrow_type}", sd)
-                result.append(sd)
-            sc = StorageContainer(dl.name, result)
-            self.arrow_tables.append(sc)
-
-    def finalize(self) -> Any:
-        result = []
-        for arr in self.arrow_tables:
-            timestamp0 = arr.ts0
-            timestamp1 = arr.ts1
-            names = ["timestamp0", "timestamp1"]
-            data = [timestamp0, timestamp1]
-            for sd in arr.arr:
-                adt = pa.array(sd.arr, type=sd.arrow_type)
-                names.append(sd.name)
-                data.append(adt)
-            table = pa.Table.from_arrays(data, names=names)
-            fname = f"{arr.name}.parquet"
-            print("Writing table", fname)
-            pq.write_table(table, fname)
-            print("done.", table.shape)
-            result.append(table)
-        return result
-
-    def on_daq_list(self, daq_list_num: int, timestamp0: int, timestamp1: int, measurements: list) -> None:
-        sc = self.arrow_tables[daq_list_num]
-        sc.ts0.append(timestamp0)
-        sc.ts1.append(timestamp1)
-        for idx, elem in enumerate(measurements):
-            sto = sc.arr[idx]
-            sto.arr.append(elem)
-
-
-decoder = Decoder(args.xmraw_file)
-res = decoder.run()

pyxcp/examples/ex_csv.py

@@ -1,85 +0,0 @@
-import argparse
-import logging
-import os
-import csv
-from array import array
-from dataclasses import dataclass, field
-from mmap import PAGESIZE
-from pathlib import Path
-from typing import Any, List
-
-from pyxcp.recorder import XcpLogFileDecoder
-from pyxcp.recorder.converter import MAP_TO_ARRAY
-
-
-MAP_TO_SQL = {
-    "U8": "INTEGER",
-    "I8": "INTEGER",
-    "U16": "INTEGER",
-    "I16": "INTEGER",
-    "U32": "INTEGER",
-    "I32": "INTEGER",
-    "U64": "INTEGER",
-    "I64": "INTEGER",
-    "F32": "FLOAT",
-    "F64": "FLOAT",
-    "F16": "FLOAT",
-    "BF16": "FLOAT",
-}
-
-logger = logging.getLogger("PyXCP")
-
-parser = argparse.ArgumentParser(description="Use .xmraw files in an Apache Arrow application.")
-parser.add_argument("xmraw_file", help=".xmraw file")
-args = parser.parse_args()
-
-
-@dataclass
-class Storage:
-    name: str
-    arrow_type: Any
-    arr: array
-
-
-@dataclass
-class StorageContainer:
-    name: str
-    arr: List[Storage] = field(default_factory=[])
-    ts0: List[int] = field(default_factory=lambda: array("Q"))
-    ts1: List[int] = field(default_factory=lambda: array("Q"))
-
-
-class Decoder(XcpLogFileDecoder):
-
-    def __init__(self, recording_file_name: str):
-        super().__init__(recording_file_name)
-
-    def initialize(self) -> None:
-        self.arrow_tables = []
-        self.csv_writers = []
-        for dl in self.daq_lists:
-            result = []
-            for name, type_str in dl.headers:
-                array_txpe = MAP_TO_ARRAY[type_str]
-                sql_type = MAP_TO_SQL[type_str]
-                sd = Storage(name, sql_type, array(array_txpe))
-                result.append(sd)
-            sc = StorageContainer(dl.name, result)
-            writer = csv.writer(open(f"{sc.name}.csv", "w", newline=""), dialect="excel")
-            headers = ["ts0", "ts1"] + [e.name for e in sc.arr]
-            writer.writerow(headers)
-            self.csv_writers.append(writer)
-            self.arrow_tables.append(sc)
-        print("\nInserting data...")
-
-    def finalize(self) -> None:
-        print("Done.")
-
-    def on_daq_list(self, daq_list_num: int, timestamp0: int, timestamp1: int, measurements: list) -> None:
-        sc = self.arrow_tables[daq_list_num]
-        writer = self.csv_writers[daq_list_num]
-        data = [timestamp0, timestamp1, *measurements]
-        writer.writerow(data)
-
-decoder = Decoder(args.xmraw_file)
-decoder.run()

pyxcp/examples/ex_excel.py

@@ -1,95 +0,0 @@
-import argparse
-import logging
-import os
-import xlsxwriter
-from array import array
-from dataclasses import dataclass, field
-from mmap import PAGESIZE
-from pathlib import Path
-from typing import Any, List
-
-from pyxcp.recorder import XcpLogFileDecoder
-from pyxcp.recorder.converter import MAP_TO_ARRAY
-
-
-MAP_TO_SQL = {
-    "U8": "INTEGER",
-    "I8": "INTEGER",
-    "U16": "INTEGER",
-    "I16": "INTEGER",
-    "U32": "INTEGER",
-    "I32": "INTEGER",
-    "U64": "INTEGER",
-    "I64": "INTEGER",
-    "F32": "FLOAT",
-    "F64": "FLOAT",
-    "F16": "FLOAT",
-    "BF16": "FLOAT",
-}
-
-logger = logging.getLogger("PyXCP")
-
-parser = argparse.ArgumentParser(description="Use .xmraw files in an Apache Arrow application.")
-parser.add_argument("xmraw_file", help=".xmraw file")
-args = parser.parse_args()
-
-
-@dataclass
-class Storage:
-    name: str
-    arrow_type: Any
-    arr: array
-
-
-@dataclass
-class StorageContainer:
-    name: str
-    arr: List[Storage] = field(default_factory=[])
-    ts0: List[int] = field(default_factory=lambda: array("Q"))
-    ts1: List[int] = field(default_factory=lambda: array("Q"))
-
-
-class Decoder(XcpLogFileDecoder):
-
-    def __init__(self, recording_file_name: str):
-        super().__init__(recording_file_name)
-        self.xls_file_name = Path(recording_file_name).with_suffix(".xlsx")
-        try:
-            os.unlink(self.xls_file_name)
-        except Exception as e:
-            print(e)
-
-    def initialize(self) -> None:
-        self.arrow_tables = []
-        self.xls_workbook = xlsxwriter.Workbook(self.xls_file_name)
-        self.xls_sheets = []
-        self.rows = []
-        for dl in self.daq_lists:
-            result = []
-            for name, type_str in dl.headers:
-                array_txpe = MAP_TO_ARRAY[type_str]
-                sql_type = MAP_TO_SQL[type_str]
-                sd = Storage(name, sql_type, array(array_txpe))
-                result.append(sd)
-            sc = StorageContainer(dl.name, result)
-            sheet = self.xls_workbook.add_worksheet(sc.name)
-            self.xls_sheets.append(sheet)
-            headers = ["ts0", "ts1"] + [e.name for e in sc.arr]
-            sheet.write_row(0, 0, headers)
-            self.rows.append(1)
-            self.arrow_tables.append(sc)
-        print("\nInserting data...")
-
-    def finalize(self) -> None:
-        self.xls_workbook.close()
-        print("Done.")
-
-    def on_daq_list(self, daq_list_num: int, timestamp0: int, timestamp1: int, measurements: list) -> None:
-        sheet = self.xls_sheets[daq_list_num]
-        row = self.rows[daq_list_num]
-        data = [timestamp0, timestamp1] + measurements
-        sheet.write_row(row, 0, data)
-        self.rows[daq_list_num] += 1
-
-decoder = Decoder(args.xmraw_file)
-decoder.run()

pyxcp/examples/ex_mdf.py

@@ -1,124 +0,0 @@
-import argparse
-import logging
-from array import array
-from dataclasses import dataclass, field
-from pathlib import Path
-from typing import Any, List
-
-import numpy as np
-from asammdf import MDF, Signal
-from asammdf.blocks.v4_blocks import HeaderBlock  # ChannelGroup
-from asammdf.blocks.v4_constants import FLAG_HD_TIME_OFFSET_VALID  # FLAG_HD_LOCAL_TIME,
-
-from pyxcp.recorder import XcpLogFileDecoder
-
-
-MAP_TO_NP = {
-    "U8": np.uint8,
-    "I8": np.int8,
-    "U16": np.uint16,
-    "I16": np.int16,
-    "U32": np.uint32,
-    "I32": np.int32,
-    "U64": np.uint64,
-    "I64": np.int64,
-    "F32": np.float32,
-    "F64": np.float64,
-    "F16": np.float16,
-    "BF16": np.float16,
-}
-
-MAP_TO_ARRAY = {
-    "U8": "B",
-    "I8": "b",
-    "U16": "H",
-    "I16": "h",
-    "U32": "L",
-    "I32": "l",
-    "U64": "Q",
-    "I64": "q",
-    "F32": "f",
-    "F64": "d",
-    "F16": "f",
-    # "BF16"
-}
-
-logger = logging.getLogger("PyXCP")
-
-parser = argparse.ArgumentParser(description="Use .xmraw files in an Apache Arrow application.")
-parser.add_argument("xmraw_file", help=".xmraw file")
-args = parser.parse_args()
-
-
-@dataclass
-class Storage:
-    name: str
-    arrow_type: Any
-    arr: array
-
-
-@dataclass
-class StorageContainer:
-    name: str
-    arr: list[Storage] = field(default_factory=[])
-    ts0: List[int] = field(default_factory=lambda: array("Q"))
-    ts1: List[int] = field(default_factory=lambda: array("Q"))
-
-
-class Decoder(XcpLogFileDecoder):
-
-    def __init__(self, recording_file_name: str):
-        super().__init__(recording_file_name)
-        self.mdf_file_name = Path(recording_file_name).with_suffix(".mf4")
-
-    def initialize(self) -> None:
-        self.tables = []
-        for dl in self.daq_lists:
-            result = []
-            for name, type_str in dl.headers:
-                array_txpe = MAP_TO_ARRAY[type_str]
-                arrow_type = MAP_TO_NP[type_str]
-                sd = Storage(name, arrow_type, array(array_txpe))
-                result.append(sd)
-            sc = StorageContainer(dl.name, result)
-            self.tables.append(sc)
-        print("Extracting DAQ lists...")
-
-    def finalize(self) -> None:
-        print("Creating MDF result...")
-        timestamp_info = self.parameters.timestamp_info
-        hdr = HeaderBlock(
-            abs_time=timestamp_info.timestamp_ns,
-            tz_offset=timestamp_info.utc_offset,
-            daylight_save_time=timestamp_info.dst_offset,
-            time_flags=FLAG_HD_TIME_OFFSET_VALID,
-        )
-        hdr.comment = f"""<HDcomment><TX>Timezone: {timestamp_info.timezone}</TX></HDcomment>"""  # Test-Comment.
-        mdf4 = MDF(version="4.10")
-        mdf4.header = hdr
-        # result = []
-        for idx, arr in enumerate(self.tables):
-            signals = []
-            timestamps = arr.ts0
-            for sd in arr.arr:
-
-                signal = Signal(samples=sd.arr, name=sd.name, timestamps=timestamps)
-                signals.append(signal)
-            print(f"Appending data-group {arr.name!r}")
-            mdf4.append(signals, acq_name=arr.name, comment="Created by pyXCP recorder")
-        print(f"Writing '{self.mdf_file_name!s}'")
-        mdf4.save(self.mdf_file_name, compression=2, overwrite=True)
-        print("Done.")
-        return mdf4
-
-    def on_daq_list(self, daq_list_num: int, timestamp0: int, timestamp1: int, measurements: list) -> None:
-        sc = self.tables[daq_list_num]
-        sc.ts0.append(timestamp0)
-        sc.ts1.append(timestamp1)
-        for idx, elem in enumerate(measurements):
-            sto = sc.arr[idx]
-            sto.arr.append(elem)
-
-
-decoder = Decoder(args.xmraw_file)
-res = decoder.run()

pyxcp/examples/ex_sqlite.py

@@ -1,128 +0,0 @@
-import argparse
-import logging
-import os
-import sqlite3
-from array import array
-from dataclasses import dataclass, field
-from mmap import PAGESIZE
-from pathlib import Path
-from typing import Any, List
-
-from pyxcp.recorder import XcpLogFileDecoder
-from pyxcp.recorder.converter import MAP_TO_ARRAY
-
-
-MAP_TO_SQL = {
-    "U8": "INTEGER",
-    "I8": "INTEGER",
-    "U16": "INTEGER",
-    "I16": "INTEGER",
-    "U32": "INTEGER",
-    "I32": "INTEGER",
-    "U64": "INTEGER",
-    "I64": "INTEGER",
-    "F32": "FLOAT",
-    "F64": "FLOAT",
-    "F16": "FLOAT",
-    "BF16": "FLOAT",
-}
-
-logger = logging.getLogger("PyXCP")
-
-parser = argparse.ArgumentParser(description="Use .xmraw files in an Apache Arrow application.")
-parser.add_argument("xmraw_file", help=".xmraw file")
-args = parser.parse_args()
-
-
-@dataclass
-class Storage:
-    name: str
-    arrow_type: Any
-    arr: array
-
-
-@dataclass
-class StorageContainer:
-    name: str
-    arr: List[Storage] = field(default_factory=[])
-    ts0: List[int] = field(default_factory=lambda: array("Q"))
-    ts1: List[int] = field(default_factory=lambda: array("Q"))
-
-
-class Decoder(XcpLogFileDecoder):
-
-    def __init__(self, recording_file_name: str):
-        super().__init__(recording_file_name)
-        self.sq3_file_name = Path(recording_file_name).with_suffix(".sq3")
-        try:
-            os.unlink(self.sq3_file_name)
-        except Exception as e:
-            print(e)
-
-    def initialize(self) -> None:
-        self.create_database(self.sq3_file_name)
-        self.arrow_tables = []
-        self.insert_stmt = {}
-        for dl in self.daq_lists:
-            result = []
-            for name, type_str in dl.headers:
-                array_txpe = MAP_TO_ARRAY[type_str]
-                sql_type = MAP_TO_SQL[type_str]
-                sd = Storage(name, sql_type, array(array_txpe))
-                result.append(sd)
-            sc = StorageContainer(dl.name, result)
-            print(f"Creating table {sc.name!r}.")
-            self.create_table(sc)
-            self.insert_stmt[sc.name] = (
-                f"""INSERT INTO {sc.name}({', '.join(['ts0', 'ts1'] + [r.name for r in sc.arr])}) VALUES({', '.join(["?" for _ in range(len(sc.arr) + 2)])})"""
-            )
-            self.arrow_tables.append(sc)
-        print("\nInserting data...")
-
-    def create_database(self, db_name: str) -> None:
-        self.conn = sqlite3.Connection(db_name)
-        self.cursor = self.conn.cursor()
-        self.execute("PRAGMA FOREIGN_KEYS=ON")
-        self.execute(f"PRAGMA PAGE_SIZE={PAGESIZE}")
-        self.execute("PRAGMA SYNCHRONOUS=OFF")
-        self.execute("PRAGMA LOCKING_MODE=EXCLUSIVE")
-        self.execute("PRAGMA TEMP_STORE=MEMORY")
-
-        timestamp_info = self.parameters.timestamp_info
-        self.execute(
-            "CREATE TABLE timestamp_info(timestamp_ns INTEGER, utc_offset INTEGER, dst_offset INTEGER, timezone VARCHAR(255))"
-        )
-        self.execute("CREATE TABLE table_names(name VARCHAR(255))")
-        self.execute(
-            "INSERT INTO timestamp_info VALUES(?, ?, ?, ?)",
-            [timestamp_info.timestamp_ns, timestamp_info.utc_offset, timestamp_info.dst_offset, timestamp_info.timezone],
-        )
-
-    def create_table(self, sc: StorageContainer) -> None:
-        columns = ["ts0 INTEGER", "ts1 INTEGER"]
-        for elem in sc.arr:
-            columns.append(f"{elem.name} {elem.arrow_type}")
-        ddl = f"CREATE TABLE {sc.name}({', '.join(columns)})"
-        self.execute(ddl)
-        self.execute("INSERT INTO table_names VALUES(?)", [sc.name])
-
-    def execute(self, *args: List[str]) -> None:
-        try:
-            self.cursor.execute(*args)
-        except Exception as e:
-            print(e)
-
-    def finalize(self) -> None:
-        self.conn.commit()
-        self.conn.close()
-        print("Done.")
-
-    def on_daq_list(self, daq_list_num: int, timestamp0: int, timestamp1: int, measurements: list) -> None:
-        sc = self.arrow_tables[daq_list_num]
-        insert_stmt = self.insert_stmt[sc.name]
-        data = [timestamp0, timestamp1, *measurements]
-        self.execute(insert_stmt, data)
-
-
-decoder = Decoder(args.xmraw_file)
-decoder.run()