objutils 0.10.1__tar.gz → 0.10.2__tar.gz

{objutils-0.10.1 → objutils-0.10.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: objutils
-Version: 0.10.1
+Version: 0.10.2
 Summary: Objectfile library for Python
 License: GPLv2
 License-File: LICENSE

{objutils-0.10.1 → objutils-0.10.2}/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.1"
+__version__ = "0.10.2"
 
 __all__ = [
     "Image",

{objutils-0.10.1 → objutils-0.10.2}/objutils/image.py

@@ -640,6 +640,28 @@ class Image:
         """Write an ASAM string datatype (ASCII/UTF8/UTF16/UTF32)."""
         self._call_address_function("write_asam_string", addr, value, dtype, **kws)
 
+    def read_asam_numeric_array(
+        self,
+        addr: int,
+        length: int,
+        dtype: str,
+        byte_order: str = "MSB_LAST",
+        **kws: Any,
+    ) -> list[Union[int, float]]:
+        """Read an ASAM numeric array with ECU byte order semantics."""
+        return self._call_address_function("read_asam_numeric_array", addr, length, dtype, byte_order, **kws)
+
+    def write_asam_numeric_array(
+        self,
+        addr: int,
+        data: Iterable[Union[int, float]],
+        dtype: str,
+        byte_order: str = "MSB_LAST",
+        **kws: Any,
+    ) -> None:
+        """Write an ASAM numeric array with ECU byte order semantics."""
+        self._call_address_function("write_asam_numeric_array", addr, data, dtype, byte_order, **kws)
+
     def read_numeric_array(self, addr: int, length: int, dtype: str, **kws: Any) -> list[Union[int, float]]:
         """Read array of numeric values from image.
 
@@ -688,6 +710,18 @@ class Image:
         """
         self._call_address_function("write_ndarray", addr, array, order=order, **kws)
 
+    def write_asam_ndarray(
+        self,
+        addr: int,
+        array: Any,
+        dtype: str,
+        byte_order: str = "MSB_LAST",
+        order: Optional[str] = None,
+        **kws: Any,
+    ) -> None:
+        """Write a NumPy ndarray using ASAM datatype and ECU byte order semantics."""
+        self._call_address_function("write_asam_ndarray", addr, array, dtype, byte_order, order=order, **kws)
+
     def read_ndarray(
         self,
         addr: int,
@@ -715,6 +749,19 @@ class Image:
         """
         return self._call_address_function("read_ndarray", addr, length, dtype, shape, order, **kws)
 
+    def read_asam_ndarray(
+        self,
+        addr: int,
+        length: int,
+        dtype: str,
+        shape: Optional[tuple[int, ...]] = None,
+        order: Optional[str] = None,
+        byte_order: str = "MSB_LAST",
+        **kws: Any,
+    ) -> Any:
+        """Read a NumPy ndarray using ASAM datatype and ECU byte order semantics."""
+        return self._call_address_function("read_asam_ndarray", addr, length, dtype, shape, order, byte_order, **kws)
+
     def read_string(self, addr: int, encoding: str = "latin1", length: int = -1, **kws: Any) -> str:
         """Read string from image.
 

{objutils-0.10.1 → objutils-0.10.2}/objutils/section.py

@@ -32,6 +32,9 @@ Architecture
     ├── read/write(addr, length)             # Raw bytes
     ├── read_numeric/write_numeric(addr, dtype)   # Single values
     ├── read_numeric_array/write_numeric_array()  # Arrays
+    ├── read_asam_numeric/write_asam_numeric()    # ASAM scalars
+    ├── read_asam_numeric_array/write_asam_numeric_array()  # ASAM arrays
+    ├── read_asam_ndarray/write_asam_ndarray()    # ASAM NumPy arrays
     ├── read_string/write_string()                # Null-terminated strings
     └── read_ndarray/write_ndarray()              # NumPy arrays
 
@@ -587,10 +590,24 @@ class Section:
         internal_dtype = ASAM_NUMERIC_DTYPES.get(normalized_dtype)
         if internal_dtype is None:
             raise TypeError(f"Unsupported ASAM datatype {asam_dtype!r}")
-        if internal_dtype in ("uint8", "int8"):
-            return internal_dtype
         return f"{internal_dtype}_{ASAM_ENDIAN_FOR_BYTEORDER[asam_byte_order]}"
 
+    def _numpy_dtype_from_internal(self, dtype: str) -> np.dtype:
+        type_, byte_order = self._verify_dtype(dtype)
+        return np.dtype(type_).newbyteorder(BYTEORDER[byte_order])
+
+    def _permute_asam_buffer(self, data: bytes, internal_dtype: str, byte_order: str) -> bytes:
+        type_name = internal_dtype.split("_")[0]
+        element_size = TYPE_SIZES.get(type_name, 0)
+        if element_size <= 1 or not data:
+            return data
+        if len(data) % element_size != 0:
+            raise ValueError("ASAM buffer length must be a multiple of the element size")
+        return b"".join(
+            self._permute_asam_bytes_for_read(data[idx : idx + element_size], byte_order)
+            for idx in range(0, len(data), element_size)
+        )
+
     def read(self, addr: int, length: int, **kws) -> bytes:
         """Read raw bytes from section at specified address.
 
@@ -763,7 +780,7 @@ class Section:
 
         fmt = self._getformat(internal_dtype)
         packed = struct.pack(fmt, value)
-        permuted = self._permute_asam_bytes_for_read(packed, asam_byte_order)
+        permuted = self._permute_asam_buffer(packed, internal_dtype, asam_byte_order)
         return struct.unpack(fmt, permuted)[0]
 
     def write_asam_numeric(
@@ -782,9 +799,44 @@ class Section:
 
         fmt = self._getformat(internal_dtype)
         packed = struct.pack(fmt, value)
-        permuted = self._permute_asam_bytes_for_write(packed, asam_byte_order)
+        permuted = self._permute_asam_buffer(packed, internal_dtype, asam_byte_order)
         self.write(addr, permuted)
 
+    def read_asam_numeric_array(
+        self,
+        addr: int,
+        length: int,
+        dtype: str,
+        byte_order: str = "MSB_LAST",
+        **kws,
+    ) -> Union[tuple[int, ...], tuple[float, ...]]:
+        asam_byte_order = self._resolve_asam_byteorder(byte_order)
+        internal_dtype = self._asam_numeric_dtype_to_internal(dtype, asam_byte_order)
+        fmt = self._getformat(internal_dtype, length)
+        data_size = struct.calcsize(fmt)
+        raw_data = self.read(addr, data_size, **kws)
+        permuted = self._permute_asam_buffer(raw_data, internal_dtype, asam_byte_order)
+        return struct.unpack(fmt, permuted)
+
+    def write_asam_numeric_array(
+        self,
+        addr: int,
+        data: Union[list[int], list[float]],
+        dtype: str,
+        byte_order: str = "MSB_LAST",
+        **kws,
+    ) -> None:
+        if not hasattr(data, "__iter__"):
+            raise TypeError("data must be iterable")
+
+        values = tuple(data)
+        asam_byte_order = self._resolve_asam_byteorder(byte_order)
+        internal_dtype = self._asam_numeric_dtype_to_internal(dtype, asam_byte_order)
+        fmt = self._getformat(internal_dtype, len(values))
+        packed = struct.pack(fmt, *values)
+        permuted = self._permute_asam_buffer(packed, internal_dtype, asam_byte_order)
+        self.write(addr, permuted, **kws)
+
     def read_asam_string(self, addr: int, dtype: str, length: int = -1, **kws) -> str:
         encoding = ASAM_STRING_ENCODINGS.get(dtype.strip().upper())
         if encoding is None:
@@ -920,6 +972,28 @@ class Section:
         else:
             self.data[offset : offset + data_size] = array.tobytes()
 
+    def write_asam_ndarray(
+        self,
+        addr: int,
+        array: np.ndarray,
+        dtype: str,
+        byte_order: str = "MSB_LAST",
+        order: str = None,
+        **kws,
+    ) -> None:
+        if not isinstance(array, np.ndarray):
+            raise TypeError("array must be of type numpy.ndarray.")
+
+        asam_byte_order = self._resolve_asam_byteorder(byte_order)
+        internal_dtype = self._asam_numeric_dtype_to_internal(dtype, asam_byte_order)
+        typed_array = np.asarray(array, dtype=self._numpy_dtype_from_internal(internal_dtype))
+        if order is not None and order == "F":
+            raw_data = fortran_array_to_buffer(array=typed_array)
+        else:
+            raw_data = typed_array.tobytes()
+        permuted = self._permute_asam_buffer(raw_data, internal_dtype, asam_byte_order)
+        self.write(addr, permuted, **kws)
+
     def read_ndarray(self, addr: int, length: int, dtype: str, shape: tuple = None, order: str = None, **kws) -> np.ndarray:
         """ """
         offset = addr - self.start_address
@@ -927,9 +1001,7 @@ class Section:
             raise InvalidAddressError(f"read_ndarray(0x{addr:08x}) access out of bounds.")
         if offset + length > self.length:
             raise InvalidAddressError(f"read_ndarray(0x{addr:08x}) access out of bounds.")
-        type_, byte_order = self._verify_dtype(dtype)
-        dt = np.dtype(type_)
-        dt = dt.newbyteorder(BYTEORDER.get(byte_order))
+        dt = self._numpy_dtype_from_internal(dtype)
         if order is not None and order == "F":
             arr = fortran_array_from_buffer(arr=self.data[offset : offset + length], shape=shape, dtype=dt)
         else:
@@ -937,6 +1009,27 @@ class Section:
             arr = flat.reshape(shape) if shape else flat
         return arr
 
+    def read_asam_ndarray(
+        self,
+        addr: int,
+        length: int,
+        dtype: str,
+        shape: tuple = None,
+        order: str = None,
+        byte_order: str = "MSB_LAST",
+        **kws,
+    ) -> np.ndarray:
+        asam_byte_order = self._resolve_asam_byteorder(byte_order)
+        internal_dtype = self._asam_numeric_dtype_to_internal(dtype, asam_byte_order)
+        dt = self._numpy_dtype_from_internal(internal_dtype)
+        raw_data = self.read(addr, length, **kws)
+        permuted = self._permute_asam_buffer(raw_data, internal_dtype, asam_byte_order)
+        if order is not None and order == "F":
+            return fortran_array_from_buffer(arr=permuted, shape=shape, dtype=dt)
+
+        flat = np.frombuffer(permuted, dtype=dt)
+        return flat.reshape(shape) if shape else flat
+
     """
     def write_timestamp():
         pass

{objutils-0.10.1 → objutils-0.10.2}/objutils/tests/test_image.py

@@ -6,6 +6,13 @@ from array import array
 
 import pytest
 
+try:
+    import numpy as np
+except ImportError:
+    NUMPY_SUPPORT = False
+else:
+    NUMPY_SUPPORT = True
+
 from objutils import dumps
 from objutils.exceptions import InvalidAddressError
 from objutils.image import Image
@@ -1343,5 +1350,25 @@ def test_image_asam_string_ascii_roundtrip():
     assert img.read_asam_string(0x1000, "ASCII") == "ABC"
 
 
+def test_image_asam_numeric_array_word_swap_32bit():
+    img = Image(Section(data=bytearray(16), start_address=0x1000))
+    img.write_asam_numeric_array(0x1000, [0x11223344, 0x55667788], "ULONG", byte_order="MSB_LAST_MSW_FIRST")
+    assert img.read(0x1000, 8) == b"\x33\x44\x11\x22\x77\x88\x55\x66"
+    assert img.read_asam_numeric_array(0x1000, 2, "ULONG", byte_order="MSB_LAST_MSW_FIRST") == (
+        0x11223344,
+        0x55667788,
+    )
+
+
+@pytest.mark.skipif("NUMPY_SUPPORT == False")
+def test_image_asam_ndarray_fortran_roundtrip():
+    img = Image(Section(data=bytearray(32), start_address=0x1000))
+    arr = np.array([[1, 2, 3], [4, 5, 6]], dtype=np.uint16)
+    img.write_asam_ndarray(0x1000, arr, "UWORD", byte_order="MSB_FIRST_MSW_LAST", order="F")
+    assert img.read(0x1000, 12) == b"\x01\x00\x04\x00\x02\x00\x05\x00\x03\x00\x06\x00"
+    result = img.read_asam_ndarray(0x1000, 12, "UWORD", shape=(3, 2), order="F", byte_order="MSB_FIRST_MSW_LAST")
+    assert np.array_equal(result, arr)
+
+
 if __name__ == "__main__":
     unittest.main()

{objutils-0.10.1 → objutils-0.10.2}/objutils/tests/test_section.py

@@ -638,6 +638,24 @@ def test_asam_float16_ieee_roundtrip():
     assert sec.read_asam_numeric(0, "FLOAT16_IEEE", byte_order="MSB_LAST") == pytest.approx(1.5, rel=1e-3)
 
 
+def test_write_asam_numeric_array_msb_last_msw_first_ulong():
+    sec = Section(data=bytearray(16))
+    sec.write_asam_numeric_array(0, [0x11223344, 0x55667788], "ULONG", byte_order="MSB_LAST_MSW_FIRST")
+    assert sec.data[:8] == bytearray([0x33, 0x44, 0x11, 0x22, 0x77, 0x88, 0x55, 0x66])
+
+
+def test_read_asam_numeric_array_msb_last_msw_first_ulong():
+    sec = Section(data=bytearray([0x33, 0x44, 0x11, 0x22, 0x77, 0x88, 0x55, 0x66] + [0x00] * 8))
+    assert sec.read_asam_numeric_array(0, 2, "ULONG", byte_order="MSB_LAST_MSW_FIRST") == (0x11223344, 0x55667788)
+
+
+def test_asam_numeric_array_signed_roundtrip():
+    sec = Section(data=bytearray(16))
+    sec.write_asam_numeric_array(0, [-1, -2, 3], "SWORD", byte_order="MSB_FIRST")
+    assert sec.data[:6] == bytearray([0xFF, 0xFF, 0xFF, 0xFE, 0x00, 0x03])
+    assert sec.read_asam_numeric_array(0, 3, "SWORD", byte_order="MSB_FIRST") == (-1, -2, 3)
+
+
 @pytest.mark.skipif("NUMPY_SUPPORT == False")
 def test_write_ndarray1():
     sec = Section(start_address=0x1000, data=bytearray(32))
@@ -819,3 +837,29 @@ def test_write_ndarray_fortan_02():
     assert sec.read(0x1000, 24) == bytearray(
         b"\x01\x00\x04\x00\x07\x00\n\x00\x02\x00\x05\x00\x08\x00\x0b\x00\x03\x00\x06\x00\t\x00\x0c\x00"
     )
+
+
+@pytest.mark.skipif("NUMPY_SUPPORT == False")
+def test_write_asam_ndarray_msb_last_msw_first_ulong():
+    sec = Section(start_address=0x1000, data=bytearray(32))
+    arr = np.array([0x11223344, 0x55667788], dtype=np.uint32)
+    sec.write_asam_ndarray(0x1000, arr, "ULONG", byte_order="MSB_LAST_MSW_FIRST")
+    assert sec.read(0x1000, 8) == bytearray([0x33, 0x44, 0x11, 0x22, 0x77, 0x88, 0x55, 0x66])
+
+
+@pytest.mark.skipif("NUMPY_SUPPORT == False")
+def test_read_asam_ndarray_msb_last_msw_first_ulong():
+    sec = Section(start_address=0x1000, data=bytearray([0x33, 0x44, 0x11, 0x22, 0x77, 0x88, 0x55, 0x66] + [0x00] * 24))
+    result = sec.read_asam_ndarray(0x1000, 8, "ULONG", shape=(2,), byte_order="MSB_LAST_MSW_FIRST")
+    assert np.array_equal(result, np.array([0x11223344, 0x55667788], dtype=np.uint32))
+
+
+@pytest.mark.skipif("NUMPY_SUPPORT == False")
+def test_asam_ndarray_fortran_roundtrip():
+    sec = Section(start_address=0x1000, data=bytearray(32))
+    arr = np.array([[1, 2, 3], [4, 5, 6]], dtype=np.uint16)
+    sec.write_asam_ndarray(0x1000, arr, "UWORD", byte_order="MSB_FIRST_MSW_LAST", order="F")
+    assert sec.read(0x1000, 12) == bytearray(b"\x01\x00\x04\x00\x02\x00\x05\x00\x03\x00\x06\x00")
+    result = sec.read_asam_ndarray(0x1000, 12, "UWORD", shape=(3, 2), order="F", byte_order="MSB_FIRST_MSW_LAST")
+    assert np.array_equal(result, arr)
+

{objutils-0.10.1 → objutils-0.10.2}/objutils/version.py

@@ -1,3 +1,3 @@
 """objutils version module"""
 
-__version__ = "0.10.1"
+__version__ = "0.10.2"

{objutils-0.10.1 → objutils-0.10.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "objutils"
-version = "0.10.1"
+version = "0.10.2"
 description = "Objectfile library for Python"
 authors = ["Christoph Schueler <cpu12.gems@googlemail.com>"]
 license = "GPLv2"
@@ -121,7 +121,7 @@ skip = ["*_i686", "*-musllinux*"]
 build-frontend = "build"
 
 [tool.bumpver]
-current_version = "0.10.1"
+current_version = "0.10.2"
 version_pattern = "MAJOR.MINOR.PATCH"
 commit_message = "bump version {old_version} -> {new_version}"
 commit = true