objutils 0.7.0__tar.gz → 0.7.2__tar.gz

{objutils-0.7.0 → objutils-0.7.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: objutils
-Version: 0.7.0
+Version: 0.7.2
 Summary: Objectfile library for Python
 License: GPLv2
 Keywords: hex files,intel hex,s19,srec,srecords,object files,map files,embedded,microcontroller,ECU,shf,rfc4194
@@ -26,6 +26,7 @@ Requires-Dist: darglint (>=1.8.1,<2.0.0)
 Requires-Dist: flake8 (>=7.0.0,<8.0.0)
 Requires-Dist: isort (>=5.13.2,<6.0.0)
 Requires-Dist: mako (>=1.3.3,<2.0.0)
+Requires-Dist: numpy (<=2.2.5)
 Requires-Dist: prettier (>=0.0.7,<0.0.8)
 Requires-Dist: rich (>=13.8.1,<14.0.0)
 Requires-Dist: sqlalchemy (>=2.0.29,<3.0.0)

{objutils-0.7.0 → objutils-0.7.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.7.0"
+__version__ = "0.7.2"
 
 __copyright__ = """
     objutils - Object file library for Python.

{objutils-0.7.0 → objutils-0.7.2}/objutils/section.py

@@ -35,11 +35,14 @@ from array import array
 from collections import namedtuple
 from copy import copy
 from dataclasses import dataclass, field
-from operator import attrgetter
+from functools import reduce
+from operator import attrgetter, mul
 from typing import Any, List, Union
 
+import numpy as np
+
 import objutils.hexdump as hexdump
-from objutils.exceptions import FeatureNotAvailableError, InvalidAddressError
+from objutils.exceptions import InvalidAddressError
 
 
 try:
@@ -176,6 +179,43 @@ def _data_converter(data: Union[str, bytearray, array, Any]) -> bytearray:
     return data
 
 
+def fortran_array_from_buffer(arr: bytearray, shape: tuple, dtype: str) -> np.ndarray:
+    if len(shape) <= 2:
+        return np.frombuffer(arr, dtype=dtype).reshape(shape[::-1]).T
+    # shape = list(reversed(shape))
+    lhs = shape[:-2]
+    num_slices = reduce(mul, lhs, 1)
+    rhs = shape[-2:]
+    slice_len = reduce(mul, rhs, 1)
+    buf = arr.copy()
+    offset = 0
+    for idx in range(num_slices):
+        ddx = buf[offset : offset + slice_len]
+        res = np.frombuffer(ddx, dtype=dtype).reshape(*reversed(rhs)).T
+        buf[offset : offset + slice_len] = res.tobytes()
+        offset += slice_len
+    return np.frombuffer(buf, dtype=dtype).reshape(shape)
+
+
+def fortran_array_to_buffer(array: np.ndarray) -> bytearray:
+    shape = array.shape
+    if array.ndim <= 2:
+        return array.tobytes("F")
+    else:
+        lhs = shape[:-2]
+        num_slices = reduce(mul, lhs, 1)
+        rhs = shape[-2:]
+        slice_len = reduce(mul, rhs, 1)
+        rs_arr = array.reshape(num_slices, *rhs)
+        offset = 0
+        result = bytearray(array.nbytes)
+        for idx in range(num_slices):
+            slice = rs_arr[idx]
+            result[offset : offset + slice_len] = slice.T.tobytes()
+            offset += slice_len
+        return result
+
+
 @dataclass(repr=False, order=True)
 class Section:
     """Manage sections.
@@ -206,7 +246,7 @@ class Section:
     def tolist(self) -> List[int]:
         return array("B", self.data).tolist()
 
-    def _verify_dtype(self, dtype):
+    def _verify_dtype(self, dtype: str) -> str:
         """ """
         dtype = dtype.lower().strip()
         if dtype == "byte":
@@ -219,7 +259,7 @@ class Section:
             raise TypeError(f"Invalid datatype {dtype!r}")
         return dtype.split("_")
 
-    def _getformat(self, dtype, length=1):
+    def _getformat(self, dtype: str, length: int = 1) -> str:
         """ """
         fmt, bo = self._verify_dtype(dtype)
 
@@ -228,7 +268,7 @@ class Section:
         else:
             return f"{BYTEORDER.get(bo)}{FORMATS.get(fmt)}"
 
-    def read(self, addr, length, **kws):
+    def read(self, addr: int, length: int, **kws) -> bytes:
         """
         Parameters
         ----------
@@ -244,7 +284,7 @@ class Section:
         data = self.data[offset : offset + length]
         return data
 
-    def write(self, addr, data, **kws):
+    def write(self, addr: int, data: bytes, **kws) -> None:
         """
         Parameters
         ----------
@@ -262,7 +302,7 @@ class Section:
             raise InvalidAddressError(f"write(0x{addr:08x}) access out of bounds.")
         self.data[offset : offset + length] = data
 
-    def read_numeric(self, addr, dtype, **kws):
+    def read_numeric(self, addr: int, dtype: str, **kws) -> Union[int, float]:
         offset = addr - self.start_address
         if offset < 0:
             raise InvalidAddressError(f"read_numeric(0x{addr:08x}) access out of bounds.")
@@ -276,7 +316,7 @@ class Section:
             data = self.apply_bitmask(data, dtype, bit_mask)
         return struct.unpack(fmt, data)[0]
 
-    def apply_bitmask(self, data, dtype, bit_mask):
+    def apply_bitmask(self, data: bytes, dtype: str, bit_mask: int) -> bytes:
         """ """
         dtype, byteorder = dtype.lower().strip().split("_")
         byteorder = "little" if byteorder == "le" else "big"
@@ -286,7 +326,7 @@ class Section:
         tmp &= bit_mask
         return tmp.to_bytes(data_size, byteorder, signed=False)
 
-    def write_numeric(self, addr, value, dtype, **kws):
+    def write_numeric(self, addr: int, value: Union[int, float], dtype: str, **kws) -> None:
         offset = addr - self.start_address
         if offset < 0:
             raise InvalidAddressError(f"write_numeric(0x{addr:08x}) access out of bounds.")
@@ -299,7 +339,7 @@ class Section:
 
         self.data[offset : offset + data_size] = struct.pack(fmt, value)
 
-    def read_numeric_array(self, addr, length, dtype, **kws):
+    def read_numeric_array(self, addr: int, length: int, dtype: str, **kws) -> Union[List[int], List[float]]:
         offset = addr - self.start_address
         if offset < 0:
             raise InvalidAddressError(f"read_numeric_array(0x{addr:08x}) access out of bounds.")
@@ -310,7 +350,7 @@ class Section:
         data = self.data[offset : offset + data_size]
         return struct.unpack(fmt, data)
 
-    def write_numeric_array(self, addr, data, dtype, **kws):
+    def write_numeric_array(self, addr: int, data: Union[List[int], List[float]], dtype: str, **kws) -> None:
         if not hasattr(data, "__iter__"):
             raise TypeError("data must be iterable")
         length = len(data)
@@ -323,7 +363,7 @@ class Section:
             raise InvalidAddressError(f"write_numeric_array(0x{addr:08x}) access out of bounds.")
         self.data[offset : offset + data_size] = struct.pack(fmt, *data)
 
-    def read_string(self, addr, encoding="latin1", length=-1, **kws):
+    def read_string(self, addr: int, encoding: str = "latin1", length: int = -1, **kws) -> str:
         offset = addr - self.start_address
         if offset < 0:
             raise InvalidAddressError(f"read_string(0x{addr:08x}) access out of bounds.")
@@ -335,19 +375,15 @@ class Section:
             raise TypeError("Unterminated String!!!")  # TODO: Testcase.
         return self.data[offset : offset + pos].decode(encoding=encoding)
 
-    def write_string(self, addr, value, encoding="latin1", **kws):
+    def write_string(self, addr: int, value: str, encoding: str = "latin1", **kws):
         offset = addr - self.start_address
         if offset < 0:
             raise InvalidAddressError(f"write_string(0x{addr:08x}) access out of bounds.")
         self.data[offset : offset + len(value)] = bytes(value, encoding=encoding)
         self.data[offset + len(value)] = 0
 
-    def write_ndarray(self, addr, array, order=None, **kws):
+    def write_ndarray(self, addr: int, array: np.ndarray, order: str = None, **kws) -> None:
         """ """
-        try:
-            import numpy as np
-        except ImportError as e:
-            raise FeatureNotAvailableError("write_ndarray() requires Numpy.") from e
         offset = addr - self.start_address
         if offset < 0:
             raise InvalidAddressError(f"write_ndarray(0x{addr:08x}) access out of bounds.")
@@ -356,36 +392,26 @@ class Section:
         data_size = array.nbytes
         if offset + data_size > self.length:
             raise InvalidAddressError(f"write_ndarray(0x{addr:08x}) access out of bounds.")
-        self.data[offset : offset + data_size] = array.tobytes()
+        if order is not None and order == "F":
+            self.data[offset : offset + data_size] = fortran_array_to_buffer(array=array)
+        else:
+            self.data[offset : offset + data_size] = array.tobytes()
 
-    def read_ndarray(self, addr, length, dtype, shape=None, order=None, **kws):
+    def read_ndarray(self, addr: int, length: int, dtype: str, shape: tuple = None, order: str = None, **kws) -> np.ndarray:
         """ """
-        try:
-            import numpy as np
-        except ImportError as e:
-            raise FeatureNotAvailableError("read_ndarray() requires Numpy.") from e
         offset = addr - self.start_address
         if offset < 0:
             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.")
-
-        """
-        If the buffer has data that is not in machine byte-order, this should
-        be specified as part of the data-type, e.g.::
-
-          >>> dt = np.dtype(int)
-          >>> dt = dt.newbyteorder('>')
-          >>> np.frombuffer(buf, dtype=dt)
-        """
         type_, byte_order = self._verify_dtype(dtype)
         dt = np.dtype(type_)
         dt = dt.newbyteorder(BYTEORDER.get(byte_order))
-        arr = np.frombuffer(self.data[offset : offset + length], dtype=dt).reshape(shape)
-        if order == "F":
-            return arr.T  # Fortran deposit, i.e. col-maj means transposition.
+        if order is not None and order == "F":
+            arr = fortran_array_from_buffer(arr=self.data[offset : offset + length], shape=shape, dtype=dt)
         else:
-            return arr
+            arr = np.frombuffer(self.data[offset : offset + length], dtype=dt).reshape(shape)
+        return arr
 
     """
     def write_timestamp():
@@ -395,33 +421,33 @@ class Section:
         pass
     """
 
-    def find(self, expr, addr=-1):
+    def find(self, expr: str, addr: int = -1) -> int:
         for item in re.finditer(bytes(expr), self.data):
             yield (self.start_address + item.start(), item.end() - item.start())
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return "Section(address = 0X{:08X}, length = {:d}, data = {})".format(
             self.start_address,
             self.length,
             self.repr.repr(memoryview(self.data).tobytes()),
         )
 
-    def __len__(self):
+    def __len__(self) -> int:
         return len(self.data)
 
     @property
-    def length(self):
+    def length(self) -> int:
         return len(self)
 
-    def __contains__(self, addr):
+    def __contains__(self, addr) -> bool:
         return self.start_address <= addr < (self.start_address + self.length)
 
     @property
-    def address(self):  # Alias
+    def address(self) -> int:  # Alias
         return self.start_address
 
 
-def join_sections(sections):
+def join_sections(sections: List[Section]) -> List[Section]:
     result_sections = []
     sections.sort(key=attrgetter("start_address"))
     prev_section = Section()

{objutils-0.7.0 → objutils-0.7.2}/objutils/tests/test_section.py

@@ -631,3 +631,139 @@ def test_read_ndarray_flat():
 
     result = sec.read_ndarray(0x1000, 24, "int32_le")
     assert np.array_equal(result, np.array([11, 22, 33, 44, 55, 66]))
+
+
+@pytest.mark.skipif("NUMPY_SUPPORT == False")
+def test_read_ndarray_fortan_01():
+    sec = Section(
+        start_address=0x1000,
+        data=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"),
+    )
+
+    result = sec.read_ndarray(0x1000, 24, shape=(3, 4), order="F", dtype="int16_le")
+    assert np.array_equal(
+        result,
+        np.array(
+            [
+                [1, 2, 3],
+                [
+                    4,
+                    5,
+                    6,
+                ],
+                [7, 8, 9],
+                [10, 11, 12],
+            ],
+            dtype=np.int16,
+        ),
+    )
+
+
+@pytest.mark.skipif("NUMPY_SUPPORT == False")
+def test_read_ndarray_fortan_02():
+    sec = Section(
+        start_address=0x1000,
+        data=[
+            1,
+            3,
+            5,
+            2,
+            4,
+            6,
+            7,
+            9,
+            11,
+            8,
+            10,
+            12,
+            13,
+            15,
+            17,
+            14,
+            16,
+            18,
+            19,
+            21,
+            23,
+            20,
+            22,
+            24,
+            25,
+            27,
+            29,
+            26,
+            28,
+            30,
+            31,
+            33,
+            35,
+            32,
+            34,
+            36,
+            37,
+            39,
+            41,
+            38,
+            40,
+            42,
+            43,
+            45,
+            47,
+            44,
+            46,
+            48,
+        ],
+    )
+
+    result = sec.read_ndarray(0x1000, 48, shape=(2, 4, 3, 2), order="F", dtype="int8_le")
+    assert np.array_equal(
+        result,
+        np.array(
+            [
+                [
+                    [[1, 2], [3, 4], [5, 6]],
+                    [[7, 8], [9, 10], [11, 12]],
+                    [[13, 14], [15, 16], [17, 18]],
+                    [[19, 20], [21, 22], [23, 24]],
+                ],
+                [
+                    [[25, 26], [27, 28], [29, 30]],
+                    [[31, 32], [33, 34], [35, 36]],
+                    [[37, 38], [39, 40], [41, 42]],
+                    [[43, 44], [45, 46], [47, 48]],
+                ],
+            ],
+            dtype=np.int8,
+        ),
+    )
+
+
+@pytest.mark.skipif("NUMPY_SUPPORT == False")
+def test_write_ndarray_fortan_01():
+    sec = Section(start_address=0x1000, data=bytearray(128))
+    arr = np.array(
+        [
+            [[[1, 2], [3, 4], [5, 6]], [[7, 8], [9, 10], [11, 12]], [[13, 14], [15, 16], [17, 18]], [[19, 20], [21, 22], [23, 24]]],
+            [
+                [[25, 26], [27, 28], [29, 30]],
+                [[31, 32], [33, 34], [35, 36]],
+                [[37, 38], [39, 40], [41, 42]],
+                [[43, 44], [45, 46], [47, 48]],
+            ],
+        ],
+        dtype=np.int8,
+    )
+    sec.write_ndarray(0x1000, arr, order="F")
+    assert sec.read(0x1000, 48) == bytearray(
+        b"\x01\x03\x05\x02\x04\x06\x07\t\x0b\x08\n\x0c\r\x0f\x11\x0e\x10\x12\x13\x15\x17\x14\x16\x18\x19\x1b\x1d\x1a\x1c\x1e\x1f!# \"$%')&(*+-/,.0"
+    )
+
+
+@pytest.mark.skipif("NUMPY_SUPPORT == False")
+def test_write_ndarray_fortan_02():
+    sec = Section(start_address=0x1000, data=bytearray(128))
+    arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]], dtype=np.int16)
+    sec.write_ndarray(0x1000, arr, order="F")
+    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"
+    )

objutils-0.7.2/objutils/utils/arduino.py

@@ -0,0 +1,51 @@
+#!/bin/python
+
+import hashlib
+import tempfile
+from pathlib import Path
+
+
+ARDUINO_TEMP_BASE_A = Path(tempfile.gettempdir()) / "arduino" / "sketches"
+ARDUINO_TEMP_BASE_B = Path(Path.home()) / "AppData" / "Local" / "arduino" / "sketches"
+
+SUFFIXES = [".eep", ".elf", ".hex", ".map"]
+
+
+def build_artifacts(sketch_name: str) -> Path:
+    """Get filenames of Arduino build artifact, e.g. elf-file."""
+    result = {}
+    path = Path(sketch_name)
+    if not path.exists():
+        raise ValueError(f"{sketch_name} not found.")
+    if path.is_file():
+        if path.suffix != ".ino":
+            raise ValueError("Expected file-extension '.ino'.")
+        path_to_dir = str(path.parent)
+    elif path.is_dir():
+        path_to_dir = str(path)
+    if ARDUINO_TEMP_BASE_A.exists():
+        base = ARDUINO_TEMP_BASE_A
+    elif ARDUINO_TEMP_BASE_B.exists():
+        base = ARDUINO_TEMP_BASE_B
+    else:
+        raise ValueError("Could not determine Arduino base directory")
+    sketch_dir = base / hashlib.md5(path_to_dir.encode("ascii")).hexdigest().upper()
+    if not sketch_dir.exists():
+        ValueError(f"directory {sketch_dir!r} does not exist.")
+    result["DIRECTORY"] = sketch_dir
+    NAMES = [f for f in sketch_dir.iterdir() if not f.is_dir() and f.suffix in SUFFIXES and "with_bootloader" not in f.name]
+    for name in NAMES:
+        result[name.suffix[1:].upper()] = name
+    return result
+
+
+if __name__ == "__main__":
+    import sys
+
+    if len(sys.argv) != 2:
+        print("usage: arduino-build-artifacts <sketch-name>")
+        sys.exit(1)
+    artifacts = build_artifacts(sys.argv[1])
+    print()
+    for name, value in artifacts.items():
+        print(f"{name:9s}: {value}")

{objutils-0.7.0 → objutils-0.7.2}/objutils/version.py

@@ -1,3 +1,3 @@
 """ objutils version module """
 
-__version__ = "0.7.0"
+__version__ = "0.7.2"

{objutils-0.7.0 → objutils-0.7.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "objutils"
-version = "0.7.0"
+version = "0.7.2"
 description = "Objectfile library for Python"
 authors = ["Christoph Schueler <cpu12.gems@googlemail.com>"]
 license = "GPLv2"
@@ -49,6 +49,7 @@ oj-elf-syms = "objutils.scripts.oj_elf_syms:main"
 oj-hex-info = "objutils.scripts.oj_hex_info:main"
 oj-elf-arm-attrs = "objutils.scripts.oj_elf_arm_attrs:main"
 oj-elf-extract = "objutils.scripts.oj_elf_extract:main"
+arduino-build-artifacts = "objutils.utils.arduino:main"
 
 
 [tool.poetry.dependencies]
@@ -63,13 +64,14 @@ prettier = "^0.0.7"
 black = "^24.4.1"
 rich = "^13.8.1"
 bandit = "^1.8.2"
+numpy = "<=2.2.5"
 
 
 [tool.poetry.group.dev.dependencies]
 pre-commit = "^3.7.0"
 pytest = "^8.1.1"
 flake8-bugbear = "^24.4.21"
-mccabe = "^0.7.0"
+mccabe = "^0.7.2"
 pycodestyle = "^2.11.1"
 pyflakes = "^3.2.0"
 ruff = "^0.4.1"