objutils 0.10.1__tar.gz → 0.10.3__tar.gz

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

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

{objutils-0.10.1 → objutils-0.10.3}/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.3"
 
 __all__ = [
     "Image",

{objutils-0.10.1 → objutils-0.10.3}/objutils/cosmac.py

@@ -5,11 +5,14 @@ This module handles the RCA Cosmac hex format, used with RCA 1802/1804/1805
 microprocessors and COSMAC development systems.
 
 Format specification:
+
 - Four data record formats with optional address:
-  1. !MAAAA DD - Full format with start symbol
-  2. ?MAAAA DD - Alternate start symbol
-  3. AAAA DD - Address only (no symbol)
-  4. DD - Data only (address continues from previous)
+
+  1. ``!MAAAA DD`` – Full format with start symbol
+  2. ``?MAAAA DD`` – Alternate start symbol
+  3. ``AAAA DD`` – Address only (no symbol)
+  4. ``DD`` – Data only (address continues from previous)
+
 - M: Memory identifier (single hex digit)
 - AAAA: 16-bit address (hex)
 - DD: Data bytes (hex, space-separated)

{objutils-0.10.1 → objutils-0.10.3}/objutils/emon52.py

@@ -5,7 +5,9 @@ This module handles the EMON52 hex format used by the Elektor
 Electronics EMON52 8052 development system.
 
 Format specification:
-- Data records: LL AAAA:DD CCCC
+
+- Data records: ``LL AAAA:DD CCCC``
+
   - LL: Length/byte count (hex)
   - AAAA: 16-bit address (hex)
   - DD: Data bytes (hex, space-separated)

{objutils-0.10.1 → objutils-0.10.3}/objutils/etek.py

@@ -5,18 +5,24 @@ This module handles the Extended Tektronix hex format, an extension
 of the standard Tektronix format with 24-bit addressing and symbol support.
 
 Format specification:
-- Data records: %LL6CCAAAAADD
-  - LL: Length field (2 * (data_length + 5) in hex)
+
+- Data records: ``%LL6CCAAAAADD``
+
+  - LL: Length field (``2 * (data_length + 5)`` in hex)
   - 6: Record type identifier
   - CC: Checksum (nibble sum)
   - AAAAAA: 24-bit address (hex)
   - DD: Data bytes (hex)
-- Symbol records: %LL3CCU
+
+- Symbol records: ``%LL3CCU``
+
   - LL: Length field
   - 3: Symbol type identifier
   - CC: Checksum
   - U: Symbol string (name + address)
-- EOF records: %LL8CCAAAAADD
+
+- EOF records: ``%LL8CCAAAAADD``
+
   - 8: EOF type identifier
 """
 
@@ -67,9 +73,9 @@ class Reader(hexfile.Reader):
     VALID_CHARS = re.compile(r"^[a-zA-Z0-9_ %\n\r]*$")
 
     FORMAT_SPEC = (
-        (DATA, "%LL6CCAAAAADD"),
+        (DATA, "%LL6CCAAAAAADD"),
         (SYMBOL, "%LL3CCU"),
-        (EOF, "%LL8CCAAAAADD"),
+        (EOF, "%LL8CCAAAAAADD"),
     )
 
     def check_line(self, line: Any, format_type: int) -> None:

{objutils-0.10.1 → objutils-0.10.3}/objutils/hexfile.py

@@ -508,6 +508,7 @@ class Container:
     length: Optional[int] = None
     type: Optional[int] = None
     checksum: Optional[int] = None
+    addrChecksum: Optional[int] = None
     chunk: Optional[bytearray] = None
     junk: Optional[str] = None
     processing_instructions: list[Any] = field(default_factory=list)
@@ -892,6 +893,7 @@ class Reader(BaseType):
                 length = self._parse_optional_int(dict_, "length")
                 record_type = self._parse_optional_int(dict_, "type")
                 checksum = self._parse_optional_int(dict_, "checksum")
+                addr_checksum = self._parse_optional_int(dict_, "addrChecksum")
                 junk = dict_.get("junk")
 
                 # Parse data chunk
@@ -912,6 +914,7 @@ class Reader(BaseType):
                     length=length,
                     type=record_type,
                     checksum=checksum,
+                    addrChecksum=addr_checksum,
                     chunk=chunk,
                     junk=junk,
                 )

{objutils-0.10.1 → objutils-0.10.3}/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.3}/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.3}/objutils/shf.py

@@ -30,7 +30,7 @@ from hashlib import sha1
 
 from objutils.image import Image
 from objutils.logger import Logger
-from objutils.section import Section
+from objutils.section import Section, join_sections
 from objutils.utils import create_string_buffer
 
 SHF_DTD = """<!--

{objutils-0.10.1 → objutils-0.10.3}/objutils/srec.py

@@ -151,14 +151,14 @@ class Reader(hexfile.Reader):
             )
         else:
             raise TypeError(f"Invalid format type {format_type}.")
-        if hasattr(line, "chunk"):
+        if hasattr(line, "chunk") and line.chunk is not None:
             checksum = (~(sum([line.length, checksum_of_address]) + sum(line.chunk))) & 0xFF
         else:
             checksum = (~(sum([line.length, checksum_of_address]))) & 0xFF
         if line.checksum != checksum:
             raise hexfile.InvalidRecordChecksumError()
         line.length -= BIAS[format_type]  # calculate actual data length.
-        if hasattr(line, "chunk") and line.length and (line.length != len(line.chunk)):
+        if hasattr(line, "chunk") and line.chunk is not None and line.length and (line.length != len(line.chunk)):
             raise hexfile.InvalidRecordLengthError("Byte count doesn't match length of actual data.")
 
     def is_data_line(self, line: Any, format_type: int) -> bool:

objutils-0.10.3/objutils/tests/test_etek.py

@@ -0,0 +1,161 @@
+#!/usr/bin/env python
+"""Tests for the Extended Tektronix (ETek) hex file format.
+
+Coverage:
+- loads(): parsing ETek → Image
+- dumps(): serialising Image → ETek
+- Roundtrip fidelity in both directions (ETek↔SREC)
+- Single-byte records at extreme 24-bit addresses
+- Checksum mismatch detection
+- Record-length mismatch detection
+"""
+
+import pytest
+
+from objutils import dumps, loads
+from objutils.hexfile import InvalidRecordChecksumError, InvalidRecordLengthError
+
+
+# ---------------------------------------------------------------------------
+# Test vectors
+# ---------------------------------------------------------------------------
+
+# 60-byte message split into three 16-byte and one 12-byte data record
+# starting at address 0xB000 (24-bit addressing).
+ETEK = (
+    b"%2A6C200B000576F77212044696420796F7520726561\n"
+    b"%2A6DF00B0106C6C7920676F207468726F7567682061\n"
+    b"%2A6CE00B0206C6C20746861742074726F75626C6520\n"
+    b"%246A700B030746F207265616420746869733F\n"
+)
+
+# Equivalent Motorola S-Record representation (used for cross-format checks).
+S19 = (
+    b"S113B000576F77212044696420796F7520726561D8\n"
+    b"S113B0106C6C7920676F207468726F756768206143\n"
+    b"S113B0206C6C20746861742074726F75626C652036\n"
+    b"S110B030746F207265616420746869733F59\n"
+    b"S5030004F8\n"
+)
+
+# Single-byte records for boundary / 24-bit address tests.
+ETEK_SINGLE_BYTE_LOW = b"%0C628000001AB\n"   # address 0x000001, data 0xAB
+ETEK_SINGLE_BYTE_HIGH = b"%0C649FF0000CD\n"  # address 0xFF0000, data 0xCD
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+
+def _etek_loads(raw: bytes):
+    """Load an ETek byte string and return the Image."""
+    return loads("etek", raw)
+
+
+def _srec_loads(raw: bytes):
+    """Load an SREC byte string and return the Image."""
+    return loads("srec", raw)
+
+
+# ---------------------------------------------------------------------------
+# loads() – parsing
+# ---------------------------------------------------------------------------
+
+
+def test_loads_produces_correct_srec_output():
+    """Parsing ETek data produces byte-identical S-Record output."""
+    img = _etek_loads(ETEK)
+    assert dumps("srec", img, s5record=True) == S19
+
+
+def test_loads_single_byte_low_address():
+    """Single data byte at address 0x000001 is read correctly."""
+    img = _etek_loads(ETEK_SINGLE_BYTE_LOW)
+    assert img.read(0x000001, 1) == b"\xAB"
+
+
+def test_loads_single_byte_high_address():
+    """Single data byte at address 0xFF0000 (max 24-bit) is read correctly."""
+    img = _etek_loads(ETEK_SINGLE_BYTE_HIGH)
+    assert img.read(0xFF0000, 1) == b"\xCD"
+
+
+def test_loads_image_min_address():
+    """Parsed image starts at the expected minimum address."""
+    img = _etek_loads(ETEK)
+    first_section = next(iter(img.sections))
+    assert first_section.start_address == 0xB000
+
+
+def test_loads_image_data_length():
+    """Parsed image contains the correct number of data bytes (61 = 3×16 + 13)."""
+    img = _etek_loads(ETEK)
+    total = sum(len(s.data) for s in img.sections)
+    assert total == 61
+
+
+# ---------------------------------------------------------------------------
+# dumps() – serialisation
+# ---------------------------------------------------------------------------
+
+
+def test_dumps_produces_correct_etek_output():
+    """Serialising an Image loaded from S-Records gives identical ETek bytes."""
+    img = _srec_loads(S19)
+    assert dumps("etek", img) == bytearray(ETEK)
+
+
+def test_dumps_single_byte_low_address():
+    """A one-byte section at address 0x000001 serialises to the expected record."""
+    img = _etek_loads(ETEK_SINGLE_BYTE_LOW)
+    assert dumps("etek", img) == bytearray(ETEK_SINGLE_BYTE_LOW)
+
+
+def test_dumps_single_byte_high_address():
+    """A one-byte section at address 0xFF0000 serialises to the expected record."""
+    img = _etek_loads(ETEK_SINGLE_BYTE_HIGH)
+    assert dumps("etek", img) == bytearray(ETEK_SINGLE_BYTE_HIGH)
+
+
+# ---------------------------------------------------------------------------
+# Roundtrip tests
+# ---------------------------------------------------------------------------
+
+
+def test_roundtrip_etek_to_srec_to_etek():
+    """ETek → SREC → ETek roundtrip preserves all data and addresses."""
+    img1 = _etek_loads(ETEK)
+    srec_data = dumps("srec", img1, s5record=True)
+    img2 = _srec_loads(srec_data)
+    assert dumps("etek", img2) == bytearray(ETEK)
+
+
+def test_roundtrip_srec_to_etek_to_srec():
+    """SREC → ETek → SREC roundtrip preserves all data and addresses."""
+    img1 = _srec_loads(S19)
+    etek_data = dumps("etek", img1)
+    img2 = _etek_loads(etek_data)
+    assert dumps("srec", img2, s5record=True) == S19
+
+
+# ---------------------------------------------------------------------------
+# Error handling
+# ---------------------------------------------------------------------------
+
+
+def test_invalid_checksum_raises():
+    """A record with a corrupted checksum raises InvalidRecordChecksumError."""
+    # Flip one nibble in the CC field (chars 4-5 of the record).
+    bad = b"%2A6FF00B000576F77212044696420796F7520726561\n"
+    with pytest.raises(InvalidRecordChecksumError):
+        _etek_loads(bad)
+
+
+def test_invalid_length_raises():
+    """A record with a wrong LL field raises InvalidRecordLengthError."""
+    # Change LL from 2A to 2C (claims 19 data bytes but only 16 are present).
+    bad = b"%2C6C200B000576F77212044696420796F7520726561\n"
+    with pytest.raises(InvalidRecordLengthError):
+        _etek_loads(bad)
+

{objutils-0.10.1 → objutils-0.10.3}/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.3}/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.3}/objutils/version.py

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

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

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "objutils"
-version = "0.10.1"
+version = "0.10.3"
 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.3"
 version_pattern = "MAJOR.MINOR.PATCH"
 commit_message = "bump version {old_version} -> {new_version}"
 commit = true