objutils 0.10.17__tar.gz → 0.10.18__tar.gz

objutils-0.10.18/.idea/objutils@1.iml

@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module external.system.id="pyproject.toml" type="PYTHON_MODULE" version="4">
+  <component name="NewModuleRootManager">
+    <content url="file://$MODULE_DIR$">
+      <excludeFolder url="file://$MODULE_DIR$/.venv" />
+      <excludeFolder url="file://$MODULE_DIR$/objutils/.venv" />
+    </content>
+    <orderEntry type="jdk" jdkName="Poetry (objutils) (2)" jdkType="Python SDK" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>

{objutils-0.10.17 → objutils-0.10.18}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: objutils
-Version: 0.10.17
+Version: 0.10.18
 Summary: Objectfile library for Python
 Keywords: hex files,intel hex,s19,srec,srecords,object files,map files,embedded,microcontroller,ECU,shf,rfc4194
 Author-Email: Christoph Schueler <cpu12.gems@googlemail.com>

{objutils-0.10.17 → objutils-0.10.18}/docs/tutorial.rst

@@ -256,6 +256,13 @@ Quick reference for the ASAM array helpers on ``Image`` and ``Section``.
    | ``ALTERNATE_WITH_Y``   | 2-D maps only: each Y-row preceded by its Y-axis  |
    |                        | coordinate value in memory                        |
    +------------------------+---------------------------------------------------+
+   | ``ALTERNATE_CURVES``   | 1-D curves sharing a common axis, stored as       |
+   |                        | Array-of-Structs (AoS).  Shape must be            |
+   |                        | ``(num_curves, num_axis_points)`` in ASAM         |
+   |                        | convention.  Equivalent to C-order ROW_DIR of     |
+   |                        | a 2-D array; returns                              |
+   |                        | ``ndarray(num_axis_points, num_curves)``.         |
+   +------------------------+---------------------------------------------------+
 
    For ``ALTERNATE_WITH_X`` / ``ALTERNATE_WITH_Y``:
 
@@ -324,6 +331,43 @@ Quick reference for the ASAM array helpers on ``Image`` and ``Section``.
    - Assuming MSW swapping affects 8-bit types (it does not).
    - Using ``ALTERNATE_WITH_X`` / ``ALTERNATE_WITH_Y`` with a 1-D array or
      without a 2-D ``shape`` parameter.
+   - Using ``ALTERNATE_CURVES`` with a 1-D array or a non-2-D ``shape``.
+
+.. rubric:: ALTERNATE_CURVES example (3 curves, 5 axis points)
+
+Corresponds to the C Array-of-Structs pattern from the ASAM specification::
+
+    typedef struct { int DT10; int DT20; int DT30; } CURVE_TYPE;
+    const CURVE_TYPE DATA[5] = {
+        {10, 3, 4}, {12, 2, 6}, {17, 9, 8}, {10, 1, 8}, {18, 3, 8},
+    };
+
+.. code-block:: python
+
+   import numpy as np
+   from objutils import Image, Section
+
+   # numpy shape (5 axis_points, 3 curves); ASAM shape (X=3, Y=5)
+   curves = np.array(
+       [[10, 3, 4],
+        [12, 2, 6],
+        [17, 9, 8],
+        [10, 1, 8],
+        [18, 3, 8]],
+       dtype=np.int32,
+   )
+   total = curves.nbytes
+   img = Image([Section(0xC000, bytes(total + 8))])
+   img.write_asam_ndarray(0xC000, curves, "SLONG", "MSB_LAST",
+                          index_mode="ALTERNATE_CURVES")
+
+   result = img.read_asam_ndarray(0xC000, 15, "SLONG",
+                                  shape=(3, 5), byte_order="MSB_LAST",
+                                  index_mode="ALTERNATE_CURVES")
+   # result.shape == (5, 3)  –  each column is one curve
+   curve_dt10 = result[:, 0]   # [10, 12, 17, 10, 18]
+   curve_dt20 = result[:, 1]   # [ 3,  2,  9,  1,  3]
+   curve_dt30 = result[:, 2]   # [ 4,  6,  8,  8,  8]
 
 .. rubric:: Copy/paste example: ULONG array roundtrip
 

{objutils-0.10.17 → objutils-0.10.18}/objutils/__init__.py

@@ -13,7 +13,7 @@ Registers CODECS and implements an interface to them.
 The first parameter is always the codec name.
 """
 
-__version__ = "0.10.17"
+__version__ = "0.10.18"
 
 __all__ = [
     "Image",

{objutils-0.10.17 → objutils-0.10.18}/objutils/image.py

@@ -812,6 +812,10 @@ class Image:
                 - ``"ALTERNATE_WITH_Y"`` – 2-D maps only; each Y-row is preceded by
                   its Y-axis coordinate value.  Pass axis values via
                   ``y_axis=<array>`` in *kws*.
+                - ``"ALTERNATE_CURVES"`` – multiple 1-D curves sharing a common axis,
+                  stored as Array-of-Structs (AoS).  Array shape must be
+                  ``(num_axis_points, num_curves)`` in numpy convention.
+                  Memory layout is identical to C-order ``ROW_DIR``.
             **kws: Keyword arguments passed through to the section method.
                 Relevant for ALTERNATE modes:
 
@@ -882,6 +886,9 @@ class Image:
                   by its X-axis coordinate value in memory.
                 - ``"ALTERNATE_WITH_Y"`` – 2-D maps only; each Y-row is preceded by
                   its Y-axis coordinate value in memory.
+                - ``"ALTERNATE_CURVES"`` – multiple 1-D curves sharing a common axis,
+                  stored as Array-of-Structs (AoS); returns
+                  ``ndarray(num_axis_points, num_curves)``.
             **kws: Keyword arguments passed through to the section method.
                 Relevant for ALTERNATE modes:
 

{objutils-0.10.17 → objutils-0.10.18}/objutils/section.py

@@ -427,7 +427,7 @@ def fortran_array_to_buffer(array: np.ndarray) -> bytearray:
         return result
 
 
-ASAM_INDEX_MODES = {"ROW_DIR", "COLUMN_DIR", "ALTERNATE_WITH_X", "ALTERNATE_WITH_Y"}
+ASAM_INDEX_MODES = {"ROW_DIR", "COLUMN_DIR", "ALTERNATE_WITH_X", "ALTERNATE_WITH_Y", "ALTERNATE_CURVES"}
 
 AlternateArrayResult = namedtuple("AlternateArrayResult", "values axis")
 
@@ -1273,7 +1273,12 @@ class Section:
             index_mode: ``"ROW_DIR"`` (default) – X increments fastest
                 (C-like row-major).  ``"COLUMN_DIR"`` – Y increments
                 fastest; only X and Y are swapped (not true column-major
-                for dims > 2).
+                for dims > 2).  ``"ALTERNATE_WITH_X"`` / ``"ALTERNATE_WITH_Y"``
+                – 2-D maps with interleaved axis values (see
+                :meth:`read_asam_ndarray`).  ``"ALTERNATE_CURVES"`` – multiple
+                1-D curves sharing a common axis, stored as Array-of-Structs;
+                array shape must be ``(num_axis_points, num_curves)`` in numpy
+                convention.
             **kws: Passed through to :meth:`write`.
 
         Raises:
@@ -1314,6 +1319,18 @@ class Section:
             # element size; for different element sizes the permutation is applied per data-dtype
             # stride which may be incorrect – a documented limitation for word-swap byte orders.
             permuted = self._permute_asam_buffer(raw_data, internal_dtype, asam_byte_order)
+        elif index_mode == "ALTERNATE_CURVES":
+            # ALTERNATE_CURVES: multiple curves sharing a common axis, stored as
+            # Array-of-Structs (AoS).  Array shape must be (num_axis_points, num_curves)
+            # in numpy convention.  Each row in memory contains all curve values at one
+            # axis breakpoint.  This is identical to C-order (ROW_DIR) for a 2-D array.
+            if typed_array.ndim != 2:
+                raise ValueError(
+                    "ALTERNATE_CURVES requires a 2-D array with shape "
+                    "(num_axis_points, num_curves) in numpy convention"
+                )
+            raw_data = typed_array.tobytes()  # C-order = AoS
+            permuted = self._permute_asam_buffer(raw_data, internal_dtype, asam_byte_order)
         else:
             raw_data = typed_array.tobytes()
             permuted = self._permute_asam_buffer(raw_data, internal_dtype, asam_byte_order)
@@ -1371,9 +1388,11 @@ class Section:
                 - ``"ALTERNATE_WITH_X"`` – 2-D maps only; columns of values alternate
                   with X-axis coordinate values.  Returns
                   :class:`AlternateArrayResult` ``(values, x_axis)``.
-                - ``"ALTERNATE_WITH_Y"`` – 2-D maps only; rows of values alternate
-                  with Y-axis coordinate values.  Returns
-                  :class:`AlternateArrayResult` ``(values, y_axis)``.
+                - ``"ALTERNATE_CURVES"`` – 1-D curves with a shared axis, stored
+                  as Array-of-Structs (AoS).  *shape* must be
+                  ``(num_curves, num_axis_points)`` in ASAM convention.
+                  Returns ``ndarray`` with shape
+                  ``(num_axis_points, num_curves)``; each column is one curve.
             **kws: Optional keyword arguments:
 
                 - ``axis_dtype`` (str): ASAM datatype of axis values for
@@ -1400,6 +1419,23 @@ class Section:
         # Convert ASAM shape (X, Y, Z …) → numpy shape (… Z, Y, X).
         numpy_shape = tuple(reversed(shape)) if shape else None
 
+        # --- ALTERNATE_CURVES --------------------------------------------------
+        if index_mode == "ALTERNATE_CURVES":
+            if numpy_shape is None or len(numpy_shape) != 2:
+                raise ValueError(
+                    "ALTERNATE_CURVES requires a 2-D shape (num_curves, num_axis_points) "
+                    "in ASAM convention"
+                )
+            type_name = internal_dtype.split("_")[0]
+            type_size = TYPE_SIZES[type_name]
+            byte_count = length * type_size
+            raw_data = self.read(addr, byte_count, **kws)
+            permuted = self._permute_asam_buffer(raw_data, internal_dtype, asam_byte_order)
+            # numpy_shape is (num_axis_points, num_curves) after ASAM reversal –
+            # exactly the shape of the C-order (AoS) buffer.
+            flat = np.frombuffer(permuted, dtype=dt)
+            return flat.reshape(numpy_shape)
+
         # --- ALTERNATE_WITH_X --------------------------------------------------
         if index_mode == "ALTERNATE_WITH_X":
             if numpy_shape is None or len(numpy_shape) != 2:

{objutils-0.10.17 → objutils-0.10.18}/objutils/tests/test_asam_alternate_modes.py

@@ -448,7 +448,7 @@ def test_alternate_invalid_index_mode_write():
     sec = Section(start_address=0, data=bytearray(32))
     arr = np.array([[1, 2]], dtype=np.uint8)
     with pytest.raises(ValueError):
-        sec.write_asam_ndarray(0, arr, "UBYTE", byte_order="MSB_LAST", index_mode="ALTERNATE_CURVES")
+        sec.write_asam_ndarray(0, arr, "UBYTE", byte_order="MSB_LAST", index_mode="INVALID_MODE")
 
 
 @pytest.mark.skipif("NUMPY_SUPPORT == False")
@@ -456,7 +456,7 @@ def test_alternate_invalid_index_mode_read():
     """Unbekannter index_mode beim Lesen: ValueError erwartet."""
     sec = Section(start_address=0, data=bytearray(32))
     with pytest.raises(ValueError):
-        sec.read_asam_ndarray(0, 4, "UBYTE", shape=(2, 2), byte_order="MSB_LAST", index_mode="ALTERNATE_CURVES")
+        sec.read_asam_ndarray(0, 4, "UBYTE", shape=(2, 2), byte_order="MSB_LAST", index_mode="INVALID_MODE")
 
 
 # ---------------------------------------------------------------------------
@@ -709,3 +709,159 @@ def test_column_dir_still_works():
     sec.write_asam_ndarray(0, arr, "UBYTE", byte_order="MSB_LAST", index_mode="COLUMN_DIR")
     result = sec.read_asam_ndarray(0, 6, "UBYTE", shape=(3, 2), byte_order="MSB_LAST", index_mode="COLUMN_DIR")
     assert np.array_equal(result, arr)
+
+
+# ---------------------------------------------------------------------------
+# ALTERNATE_CURVES
+# ---------------------------------------------------------------------------
+# Spezifikation: Mehrere 1-D Kurven teilen eine gemeinsame Achse und werden als
+# Array-of-Structs (AoS) gespeichert. Jede Speicherzeile enthält alle Kurven-Werte
+# für einen Achsbreakpoint.  Dies entspricht exakt C-Order (ROW_DIR) einer 2-D
+# Matrix mit Shape (num_axis_points, num_curves) in numpy-Konvention.
+#
+# C-Äquivalent aus der ASAM-Spezifikation:
+#   typedef struct { int DT10; int DT20; int DT30; int DT40; } VXP_TYPE;
+#   const VXP_TYPE VX_PLUS_DELAY_TIMES[5] = {
+#       { 10, 3, 4, 8 }, { 12, 2, 4, 6 }, { 17, 9, 5, 8 },
+#       { 10, 1, 4, 8 }, { 18, 3, 8, 8 },
+#   };
+# Speicher: 10, 3, 4, 8, 12, 2, 4, 6, 17, 9, 5, 8, 10, 1, 4, 8, 18, 3, 8, 8
+# ---------------------------------------------------------------------------
+
+# Das Beispiel-Array aus der Spezifikation: 5 Achsbreakpoints × 4 Kurven
+VXP_TYPE_DATA = np.array(
+    [
+        [10, 3, 4, 8],   # Breakpoint 0
+        [12, 2, 4, 6],   # Breakpoint 1
+        [17, 9, 5, 8],   # Breakpoint 2
+        [10, 1, 4, 8],   # Breakpoint 3
+        [18, 3, 8, 8],   # Breakpoint 4
+    ],
+    dtype=np.int32,
+)
+
+VXP_FLAT_LE = [
+    10, 0, 0, 0,   3, 0, 0, 0,   4, 0, 0, 0,   8, 0, 0, 0,
+    12, 0, 0, 0,   2, 0, 0, 0,   4, 0, 0, 0,   6, 0, 0, 0,
+    17, 0, 0, 0,   9, 0, 0, 0,   5, 0, 0, 0,   8, 0, 0, 0,
+    10, 0, 0, 0,   1, 0, 0, 0,   4, 0, 0, 0,   8, 0, 0, 0,
+    18, 0, 0, 0,   3, 0, 0, 0,   8, 0, 0, 0,   8, 0, 0, 0,
+]  # 5 * 4 * 4 = 80 Bytes (SLONG, LE)
+
+
+@pytest.mark.skipif("NUMPY_SUPPORT == False")
+def test_alternate_curves_memory_layout_ubyte():
+    """ALTERNATE_CURVES: Rohspeicher entspricht AoS-Layout (C-Order).
+
+    5 Breakpoints × 4 Kurven, UBYTE.
+    Speicher: row0=[10,3,4,8], row1=[12,2,4,6], …
+    """
+    arr = VXP_TYPE_DATA.astype(np.uint8)
+    expected = [
+        10, 3, 4, 8,
+        12, 2, 4, 6,
+        17, 9, 5, 8,
+        10, 1, 4, 8,
+        18, 3, 8, 8,
+    ]
+    total_bytes = 5 * 4  # num_axis_points * num_curves
+    sec = Section(start_address=0x1000, data=bytearray(total_bytes + 8))
+    sec.write_asam_ndarray(0x1000, arr, "UBYTE", byte_order="MSB_LAST", index_mode="ALTERNATE_CURVES")
+    assert list(sec.read(0x1000, total_bytes)) == expected
+
+
+@pytest.mark.skipif("NUMPY_SUPPORT == False")
+def test_alternate_curves_roundtrip_ubyte():
+    """ALTERNATE_CURVES: Write → Read Roundtrip (UBYTE)."""
+    arr = VXP_TYPE_DATA.astype(np.uint8)  # numpy shape (5, 4)
+
+    total_bytes = 5 * 4
+    sec = Section(start_address=0x2000, data=bytearray(total_bytes + 16))
+    # ASAM shape (X=num_curves=4, Y=num_axis_points=5)
+    sec.write_asam_ndarray(0x2000, arr, "UBYTE", byte_order="MSB_LAST", index_mode="ALTERNATE_CURVES")
+    result = sec.read_asam_ndarray(0x2000, 20, "UBYTE", shape=(4, 5), byte_order="MSB_LAST", index_mode="ALTERNATE_CURVES")
+    assert result.shape == (5, 4)  # numpy: (num_axis_points, num_curves)
+    assert np.array_equal(result, arr)
+
+
+@pytest.mark.skipif("NUMPY_SUPPORT == False")
+def test_alternate_curves_roundtrip_slong_le():
+    """ALTERNATE_CURVES: Roundtrip mit SLONG (32-Bit LE) – Spec-Beispiel."""
+    # ASAM shape: (X=4 Kurven, Y=5 Breakpoints)
+    total_bytes = 5 * 4 * 4  # 5 breakpoints × 4 curves × 4 bytes
+    sec = Section(start_address=0, data=bytearray(total_bytes + 16))
+    sec.write_asam_ndarray(0, VXP_TYPE_DATA, "SLONG", byte_order="MSB_LAST", index_mode="ALTERNATE_CURVES")
+    result = sec.read_asam_ndarray(0, 20, "SLONG", shape=(4, 5), byte_order="MSB_LAST", index_mode="ALTERNATE_CURVES")
+    assert result.shape == (5, 4)
+    assert np.array_equal(result, VXP_TYPE_DATA)
+
+
+@pytest.mark.skipif("NUMPY_SUPPORT == False")
+def test_alternate_curves_raw_memory_slong_le():
+    """ALTERNATE_CURVES: Rohspeicher stimmt mit AoS-Layout überein (SLONG LE)."""
+    total_bytes = 5 * 4 * 4
+    sec = Section(start_address=0, data=bytearray(total_bytes + 8))
+    sec.write_asam_ndarray(0, VXP_TYPE_DATA, "SLONG", byte_order="MSB_LAST", index_mode="ALTERNATE_CURVES")
+    assert list(sec.read(0, total_bytes)) == VXP_FLAT_LE
+
+
+@pytest.mark.skipif("NUMPY_SUPPORT == False")
+def test_alternate_curves_individual_curve_access():
+    """ALTERNATE_CURVES: Einzelne Kurven per Spalten-Slice abrufbar."""
+    arr = VXP_TYPE_DATA.astype(np.uint8)
+    total_bytes = 5 * 4
+    sec = Section(start_address=0, data=bytearray(total_bytes + 8))
+    sec.write_asam_ndarray(0, arr, "UBYTE", byte_order="MSB_LAST", index_mode="ALTERNATE_CURVES")
+    result = sec.read_asam_ndarray(0, 20, "UBYTE", shape=(4, 5), byte_order="MSB_LAST", index_mode="ALTERNATE_CURVES")
+
+    # Kurve 0 (DT10): [10, 12, 17, 10, 18]
+    assert list(result[:, 0]) == [10, 12, 17, 10, 18]
+    # Kurve 1 (DT20): [3, 2, 9, 1, 3]
+    assert list(result[:, 1]) == [3, 2, 9, 1, 3]
+    # Kurve 2 (DT30): [4, 4, 5, 4, 8]
+    assert list(result[:, 2]) == [4, 4, 5, 4, 8]
+    # Kurve 3 (DT40): [8, 6, 8, 8, 8]
+    assert list(result[:, 3]) == [8, 6, 8, 8, 8]
+
+
+@pytest.mark.skipif("NUMPY_SUPPORT == False")
+def test_alternate_curves_big_endian():
+    """ALTERNATE_CURVES mit BE (MSB_FIRST)."""
+    arr = np.array([[0x0102, 0x0304], [0x0506, 0x0708]], dtype=np.uint16)  # 2 Breakpoints, 2 Kurven
+    # BE-Speicher: 0x01 0x02  0x03 0x04  0x05 0x06  0x07 0x08
+    expected = [0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08]
+    total_bytes = 2 * 2 * 2
+    sec = Section(start_address=0, data=bytearray(total_bytes + 8))
+    sec.write_asam_ndarray(0, arr, "UWORD", byte_order="MSB_FIRST", index_mode="ALTERNATE_CURVES")
+    assert list(sec.read(0, total_bytes)) == expected
+    result = sec.read_asam_ndarray(0, 4, "UWORD", shape=(2, 2), byte_order="MSB_FIRST", index_mode="ALTERNATE_CURVES")
+    assert np.array_equal(result, arr)
+
+
+@pytest.mark.skipif("NUMPY_SUPPORT == False")
+def test_alternate_curves_requires_2d():
+    """ALTERNATE_CURVES mit 1-D Array: ValueError erwartet."""
+    sec = Section(start_address=0, data=bytearray(32))
+    arr = np.array([1, 2, 3], dtype=np.uint8)
+    with pytest.raises(ValueError, match="2-D"):
+        sec.write_asam_ndarray(0, arr, "UBYTE", byte_order="MSB_LAST", index_mode="ALTERNATE_CURVES")
+
+
+@pytest.mark.skipif("NUMPY_SUPPORT == False")
+def test_alternate_curves_read_requires_2d_shape():
+    """ALTERNATE_CURVES beim Lesen ohne 2-D shape: ValueError erwartet."""
+    sec = Section(start_address=0, data=bytearray(32))
+    with pytest.raises(ValueError, match="2-D"):
+        sec.read_asam_ndarray(0, 4, "UBYTE", shape=(4,), byte_order="MSB_LAST", index_mode="ALTERNATE_CURVES")
+
+
+@pytest.mark.skipif("NUMPY_SUPPORT == False")
+def test_alternate_curves_layout_equals_row_dir():
+    """ALTERNATE_CURVES und ROW_DIR erzeugen identisches Speicher-Layout."""
+    arr = np.array([[1, 2, 3], [4, 5, 6]], dtype=np.uint8)
+    sec_curves = Section(start_address=0, data=bytearray(16))
+    sec_row    = Section(start_address=0, data=bytearray(16))
+    sec_curves.write_asam_ndarray(0, arr, "UBYTE", byte_order="MSB_LAST", index_mode="ALTERNATE_CURVES")
+    sec_row.write_asam_ndarray(   0, arr, "UBYTE", byte_order="MSB_LAST", index_mode="ROW_DIR")
+    assert sec_curves.read(0, 6) == sec_row.read(0, 6)
+

{objutils-0.10.17 → objutils-0.10.18}/objutils/version.py

@@ -1,3 +1,3 @@
 """objutils version module"""
 
-__version__ = "0.10.17"
+__version__ = "0.10.18"

{objutils-0.10.17 → objutils-0.10.18}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "scikit_build_core.build"
 
 [project]
 name = "objutils"
-version = "0.10.17"
+version = "0.10.18"
 description = "Objectfile library for Python"
 authors = [
     {name = "Christoph Schueler", email = "cpu12.gems@googlemail.com"}
@@ -126,7 +126,7 @@ skip = ["*_i686", "*-musllinux*"]
 build-frontend = "build"
 
 [tool.bumpver]
-current_version = "0.10.17"
+current_version = "0.10.18"
 version_pattern = "MAJOR.MINOR.PATCH"
 commit_message = "bump version {old_version} -> {new_version}"
 commit = true