Recorder package

.gitignore

@@ -128,3 +128,6 @@ result.xml
 
 # VIM temporaries
 *~
+/pyxcp/recorder/mio/
+/pyxcp/recorder/simde/
+/pyxcp/recorder/coro/

pyxcp/recorder/__init__.py

@@ -1,6 +1,74 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
-"""Frame Recording Facility.
+"""XCP Frame Recording Facility.
 """
-from .reco import XcpLogFileReader
-from .reco import XcpLogFileWriter
+from dataclasses import dataclass
+from enum import IntEnum
+
+try:
+    import numpy as np
+    import pandas as pd
+except ImportError:
+    HAS_PANDAS = False
+else:
+    HAS_PANDAS = True
+
+import rekorder as rec
+
+
+@dataclass
+class XcpLogFileHeader:
+    """ """
+
+    num_containers: int
+    record_count: int
+    size_uncompressed: int
+    size_compressed: int
+    compression_ratio: float
+
+
+class FrameCategory(IntEnum):
+    """ """
+
+    META = 0
+    CMD = 1
+    RES = 2
+    ERR = 3
+    EV = 4
+    SERV = 5
+    DAQ = 6
+    STIM = 7
+
+
+COUNTER_MAX = 0xFFFF
+
+
+class XcpLogFileReader:
+    """ """
+
+    def __init__(self, file_name):
+        self._reader = rec._PyXcpLogFileReader(file_name)
+
+    def get_header(self):
+        return XcpLogFileHeader(*self._reader.get_header_as_tuple())
+
+    def __iter__(self):
+        while True:
+            frames = self._reader.next_block()
+            if frames is None:
+                break
+            for category, counter, timestamp, _, payload in frames:
+                yield (category, counter, timestamp, payload)
+
+
+class XcpLogFileWriter:
+    """ """
+
+    def __init__(self, file_name, p=10, c=1):
+        self._writer = rec._PyXcpLogFileWriter(file_name, p, c)
+
+    def add_frame(self, category: FrameCategory, counter: int, timestamp: float, payload: bytes):
+        self._writer.add_frame(category, counter % (COUNTER_MAX + 1), timestamp, len(payload), payload)
+
+    def finalize(self):
+        self._writer.finalize()

pyxcp/recorder/test_reko.py

@@ -1,55 +1,37 @@
-import struct
-import time
-from functools import partial
-from random import choice
-from random import randint
-
-import reco
-
-CNT = 1024 * 10 * 5
-
-ri = partial(randint, 0, 255)
-
-rs = [ri() for _ in range(CNT)]
-
-# print(dir(time))
-TS_STRUCT = struct.Struct("<Hd")
-
-frames = []
-for counter in range(CNT):
-    ts = time.perf_counter()
-    length = choice(rs)
-    db = bytes([choice(rs)] * length)
-
-    FS = "<H{}s".format(length)
-    frame = struct.Struct(FS).pack(length, db)
-    # print(length, db)
-    # frame = TS_STRUCT.pack(
-    #   counter, ts
-    # )
-    frames.append([counter, ts, frame])
-
-# help(bytes)
-DAQ_RECORD_STRUCT = struct.Struct("<BHdL")
-# DAQRecord = namedtuple("DAQRecord", "category counter timestamp payload")
-
-log = reco.XcpLogFileWriter("test_logger")
-
-print(log)
-log.add_xcp_frames(frames)
-
-"""
-def wockser(self, catagory, *args):
-        response, counter, length, timestamp = args
-        #print(catagory, response, counter, length, timestamp)   # .tobytes()
-        raw_data = response.tobytes()
-        self.intermediate_storage.append((counter, timestamp, raw_data, ))
-        #li = DAQ_RECORD_STRUCT.pack(1, counter, timestamp, length)
-        self.uncompressed_size += len(raw_data) + 12
-        if self.uncompressed_size > 10 * 1024:
-            #print("PUSH to worker!!")
-            self.log_writer.add_xcp_frames(self.intermediate_storage)
-            self.intermediate_storage = []
-            self.uncompressed_size = 0
-
-"""
+from time import perf_counter
+
+import pandas as pd
+
+from pyxcp.recorder import FrameCategory
+from pyxcp.recorder import XcpLogFileReader
+from pyxcp.recorder import XcpLogFileWriter
+
+writer = XcpLogFileWriter("test_logger", p=220)
+# for idx in range(255):
+for idx in range(512 * 1024):
+    value = idx % 256
+    writer.add_frame(1, idx, perf_counter(), [value] * value)
+writer.finalize()
+del writer
+# """
+
+print("Before c-tor()")
+reader = XcpLogFileReader("test_logger")
+print("After c-tor()")
+hdr = reader.get_header()
+print(hdr)
+
+cnt = 0
+
+df = pd.DataFrame((f for f in reader), columns=["category", "counter", "timestamp", "payload"])
+df = df.set_index("timestamp")
+df.category = df.category.map({v: k for k, v in FrameCategory.__members__.items()}).astype("category")
+print(df)
+print(df.info())
+print(df.describe())
+
+# for frame in reader:
+#    print(frame)
+#    cnt += 1
+
+print("Finished.")