Development

.github/workflows/build.yml

@@ -44,9 +44,9 @@ jobs:
             pip install cmerg
             if [ "$RUNNER_OS" == "Linux" ]; then
                  sudo apt update
-                 sudo apt install libegl1
+                 sudo apt install libegl1 libopengl0
             fi
-            pyinstaller asammdf.spec --distpath dist/${RUNNER_OS} --noconfirm --clean --onefile
+            pyinstaller asammdf.spec --distpath dist/${RUNNER_OS} --noconfirm --clean
 
       # see: https://docs.github.com/en/actions/advanced-guides/storing-workflow-data-as-artifacts
       - name: Archive dist artifacts

asammdf.spec

@@ -7,33 +7,6 @@ import sys
 asammdf_path = Path.cwd() / "asammdf" / "gui" / "asammdfgui.py"
 
 
-def _cmd_line_parser():
-    parser = argparse.ArgumentParser()
-
-    parser.add_argument(
-        "spec",
-        help="specfile",
-    )
-
-    parser.add_argument(
-        "--console",
-        action="store_true",
-        help="show console, default False",
-    )
-
-    parser.add_argument(
-        "--onefile",
-        action="store_true",
-        help="create single file, default False",
-    )
-
-    return parser
-
-
-parser = _cmd_line_parser()
-args, unknown = parser.parse_known_args(sys.argv[1:])
-
-
 block_cipher = None
 added_files = []
 
@@ -74,49 +47,32 @@ a = Analysis(
     win_no_prefer_redirects=False,
     win_private_assemblies=False,
     cipher=block_cipher,
-    noarchive=not args.onefile,
+    noarchive=False,
 )
 
-if args.onefile:
-    pyz = PYZ(a.pure, a.zipped_data, cipher=block_cipher)
 
-    exe = EXE(
-        pyz,
-        a.scripts,
-        a.binaries,
-        a.zipfiles,
-        a.datas,
-        Tree(asammdf_path.parent),
-        name="asammdfgui",
-        debug=False,
-        strip=False,
-        upx=True,
-        console=args.console,
-        icon="asammdf.ico",
-    )
-else:
-    pyz = PYZ(a.pure, a.zipped_data, cipher=block_cipher)
+pyz = PYZ(a.pure, a.zipped_data, cipher=block_cipher)
 
-    exe = EXE(
-        pyz,
-        a.scripts,
-        [],
-        name="asammdfgui",
-        exclude_binaries=True,
-        bootloader_ignore_signals=False,
-        debug=False,
-        strip=False,
-        console=args.console,
-        icon="asammdf.ico",
-    )
+exe = EXE(
+    pyz,
+    a.scripts,
+    [],
+    name="asammdfgui",
+    exclude_binaries=True,
+    bootloader_ignore_signals=False,
+    debug=False,
+    strip=False,
+    console=False,
+    icon="asammdf.ico",
+)
 
-    coll = COLLECT(
-        exe,
-        a.binaries,
-        a.zipfiles,
-        a.datas,
-        Tree(asammdf_path.parent),
-        upx=False,
-        upx_exclude=[],
-        name="asammdfgui",
-    )
+coll = COLLECT(
+    exe,
+    a.binaries,
+    a.zipfiles,
+    a.datas,
+    Tree(asammdf_path.parent),
+    upx=False,
+    upx_exclude=[],
+    name="asammdfgui",
+)

asammdf/blocks/conversion_utils.py

@@ -5,7 +5,7 @@
 
 from __future__ import annotations
 
-from typing import Any
+from typing import Any, Union
 
 from . import v2_v3_blocks as v3b
 from . import v2_v3_constants as v3c
@@ -392,3 +392,98 @@ def from_dict(conversion: dict[str, Any]) -> v4b.ChannelConversion:
         conversion = v4b.ChannelConversion(conversion_type=v4c.CONVERSION_TYPE_NON)
 
     return conversion
+
+
+def to_dict(conversion: ChannelConversionType) -> Union[dict, None]:
+    if not conversion:
+        return None
+
+    if isinstance(conversion, v3b.ChannelConversion):
+        conversion = conversion_transfer(conversion, version=4)
+
+    conversion_type = conversion.conversion_type
+
+    conversion_dict = {
+        "name": conversion.name,
+        "unit": conversion.unit,
+        "comment": conversion.comment,
+    }
+
+    if conversion_type == v4c.CONVERSION_TYPE_LIN:
+        conversion_dict["a"] = conversion.a
+        conversion_dict["b"] = conversion.b
+        conversion_dict["conversion_type"] = conversion_type
+
+    elif conversion_type == v4c.CONVERSION_TYPE_ALG:
+        conversion_dict["formula"] = conversion["formula"]
+        conversion_dict["conversion_type"] = conversion_type
+
+    elif conversion_type == v4c.CONVERSION_TYPE_RAT:
+        conversion_dict.update(
+            {key: conversion[key] for key in [f"P{i}" for i in range(1, 7)]}
+        )
+        conversion_dict["conversion_type"] = conversion_type
+
+    elif conversion_type in (v4c.CONVERSION_TYPE_TAB, v4c.CONVERSION_TYPE_TABI):
+        params = conversion["val_param_nr"] // 2
+        conversion_dict.update(
+            {key: conversion[key] for key in [f"phys_{nr}" for nr in range(params)]}
+        )
+        conversion_dict.update(
+            {key: conversion[key] for key in [f"raw_{nr}" for nr in range(params)]}
+        )
+        conversion_dict["conversion_type"] = conversion_type
+
+    elif conversion_type == v4c.CONVERSION_TYPE_RTAB:
+        params = (conversion["val_param_nr"] - 1) // 3
+        conversion_dict.update(
+            {key: conversion[key] for key in [f"lower_{nr}" for nr in range(params)]}
+        )
+        conversion_dict.update(
+            {key: conversion[key] for key in [f"upper_{nr}" for nr in range(params)]}
+        )
+        conversion_dict.update(
+            {key: conversion[key] for key in [f"phys_{nr}" for nr in range(params)]}
+        )
+        conversion_dict["conversion_type"] = conversion_type
+        conversion_dict["default"] = conversion.default
+
+    elif conversion_type == v4c.CONVERSION_TYPE_TABX:
+        nr = conversion.ref_param_nr - 1
+
+        conversion_dict["conversion_type"] = conversion_type
+
+        for key, val in conversion.referenced_blocks.items():
+
+            if isinstance(val, str):
+                conversion_dict[key] = val
+            elif isinstance(val, v4b.ChannelConversion):
+                conversion_dict[key] = to_dict(val)
+            else:
+                conversion_dict[key] = val.decode("utf-8", errors="replace")
+
+        for i in range(nr):
+            conversion_dict[f"val_{i}"] = conversion[f"val_{i}"]
+
+    elif conversion_type == v4c.CONVERSION_TYPE_RTABX:
+        nr = conversion.ref_param_nr - 1
+
+        conversion_dict["conversion_type"] = conversion_type
+
+        for key, val in conversion.referenced_blocks.items():
+
+            if isinstance(val, str):
+                conversion_dict[key] = val
+            elif isinstance(val, v4b.ChannelConversion):
+                conversion_dict[key] = to_dict(val)
+            else:
+                conversion_dict[key] = val.decode("utf-8", errors="replace")
+
+        for i in range(nr):
+            conversion_dict[f"upper_{i}"] = conversion[f"upper_{i}"]
+            conversion_dict[f"lower_{i}"] = conversion[f"lower_{i}"]
+
+    else:
+        conversion_dict = None
+
+    return conversion_dict

asammdf/blocks/cutils.c

@@ -6,6 +6,7 @@
 #include "numpy/ndarrayobject.h"
 #include <stdio.h>
 #include <stdbool.h>
+#include <time.h>
 
 #define PY_PRINTF(o) \
     PyObject_Print(o, stdout, 0); printf("\n");
@@ -72,22 +73,28 @@ static PyObject* sort_data_block(PyObject* self, PyObject* args)
             for (unsigned char i=0; i<id_size; i++, buf++) {
                 rec_id += (*buf) << (i <<3);
             }  
-
-            mlist = NULL;
-            for (item=head; item!=NULL; item=item->next)
-            {
-                if (item->info.id == rec_id)
-                {
-                    rec_size = item->info.size;
-                    mlist = item->info.mlist;
-                    break;
-                }
+
+            key = PyLong_FromUnsignedLong(rec_id);
+            value = PyDict_GetItem(record_size, key);
+
+            if (!value) {
+                rem = PyBytes_FromStringAndSize(NULL, 0);
+                Py_XDECREF(key);
+                return rem;
             }
-
+            else {
+                rec_size = PyLong_AsUnsignedLong(value);
+            }
+
+            mlist = PyDict_GetItem(partial_records, key);
+
             if (!mlist) {
                 rem = PyBytes_FromStringAndSize(NULL, 0);
+                Py_XDECREF(key);
                 return rem;
             }
+
+            Py_XDECREF(key);
 
             if (rec_size)
             {

asammdf/blocks/mdf_v2.py

@@ -7,7 +7,7 @@
 
 from ..types import StrPathType
 from .mdf_v3 import MDF3
-from .utils import validate_version_argument
+from .utils import MdfException, validate_version_argument
 
 __all__ = ["MDF2"]
 
@@ -27,6 +27,11 @@ def __init__(
     ) -> None:
         version = validate_version_argument(version, hint=2)
 
+        if not kwargs.get("__internal__", False):
+            raise MdfException(
+                "Always use the MDF class; do not use the class MDF2 directly"
+            )
+
         super().__init__(name, version, **kwargs)
 
 

asammdf/blocks/mdf_v3.py

@@ -173,6 +173,11 @@ def __init__(
         channels: list[str] | None = None,
         **kwargs,
     ) -> None:
+        if not kwargs.get("__internal__", False):
+            raise MdfException(
+                "Always use the MDF class; do not use the class MDF3 directly"
+            )
+
         self._kwargs = kwargs
         self.original_name = kwargs["original_name"]
         if channels is None:
@@ -538,15 +543,10 @@ def _prepare_record(self, group: Group) -> list:
 
                 if not new_ch.component_addr:
 
-                    if not new_ch.dtype_fmt:
-                        new_ch.dtype_fmt = dtype(
-                            get_fmt_v3(data_type, bit_count, byte_order)
-                        )
-
                     # adjust size to 1, 2, 4 or 8 bytes
                     size = bit_offset + bit_count
 
-                    byte_size, rem = size // 8, size % 8
+                    byte_size, rem = divmod(size, 8)
                     if rem:
                         byte_size += 1
                     bit_size = byte_size * 8
@@ -562,6 +562,11 @@ def _prepare_record(self, group: Group) -> list:
                         elif size > 8:
                             bit_offset += 16 - bit_size
 
+                    if not new_ch.dtype_fmt:
+                        new_ch.dtype_fmt = dtype(
+                            get_fmt_v3(data_type, size, byte_order)
+                        )
+
                     record.append(
                         (
                             new_ch.dtype_fmt,
@@ -3104,6 +3109,7 @@ def get(
 
         if vals.dtype.kind == "S":
             encoding = "latin-1"
+            vals = array([e.rsplit(b"\0")[0] for e in vals.tolist()], dtype=vals.dtype)
 
         if samples_only:
             res = vals, None