objutils 0.10.15__tar.gz → 0.10.16__tar.gz

{objutils-0.10.15 → objutils-0.10.16}/.pre-commit-config.yaml

@@ -42,7 +42,7 @@ repos:
         args: ["--line-length=132"]
 
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.16.0
+    rev: v0.16.1
     hooks:
       - id: ruff
         args: ["--fix", "--exit-non-zero-on-fix"]

{objutils-0.10.15 → objutils-0.10.16}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: objutils
-Version: 0.10.15
+Version: 0.10.16
 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.15 → objutils-0.10.16}/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.15"
+__version__ = "0.10.16"
 
 __all__ = [
     "Image",

{objutils-0.10.15 → objutils-0.10.16}/objutils/dwarf/__init__.py

@@ -300,7 +300,6 @@ class Readers:
     """
 
 
-
 @dataclass
 class DIEAttribute:
     """Parsed DIE attribute with value.

{objutils-0.10.15 → objutils-0.10.16}/objutils/dwarf/encoding.py

@@ -64,12 +64,10 @@ class ULEBError(ConstructError):
     """Raised when ULEB128 parsing or building encounters an error."""
 
 
-
 class SLEBError(ConstructError):
     """Raised when SLEB128 parsing or building encounters an error."""
 
 
-
 @singleton
 class ULEB(Construct):
     """Unsigned LEB128 (Little-Endian Base-128) Variable-Length Integer.

{objutils-0.10.15 → objutils-0.10.16}/objutils/dwarf/readers.py

@@ -69,7 +69,6 @@ class Readers:
     """
 
 
-
 class DwarfReaders:
     """High-Level DWARF Data Reader Interface.
 

{objutils-0.10.15 → objutils-0.10.16}/objutils/elf/model.py

@@ -1183,7 +1183,6 @@ class DebugInformation(Base, RidMixIn):
     """
 
 
-
 class CompilationUnit(Base, RidMixIn):
     __tablename__ = "compilationunit"
     """ORM model for DWARF Compilation Unit (CU).
@@ -1193,7 +1192,6 @@ class CompilationUnit(Base, RidMixIn):
     """
 
 
-
 def calculateCacheSize(value: int) -> int:
     """Convert cache size in bytes to SQLite PRAGMA format.
 

{objutils-0.10.15 → objutils-0.10.16}/objutils/hexfile.py

@@ -335,32 +335,26 @@ class HexFileError(Exception):
     """Base exception for all hex file operations."""
 
 
-
 class ParseError(HexFileError):
     """Base for parsing-related errors."""
 
 
-
 class InvalidRecordTypeError(ParseError):
     """Raised when record type is not recognized."""
 
 
-
 class InvalidRecordLengthError(ParseError):
     """Raised when record length doesn't match data."""
 
 
-
 class InvalidRecordChecksumError(ParseError):
     """Raised when checksum validation fails."""
 
 
-
 class AddressRangeToLargeError(HexFileError):
     """Raised when address exceeds format capabilities."""
 
 
-
 # Deprecated alias for backward compatibility
 Invalidrecord_typeError = InvalidRecordTypeError
 

{objutils-0.10.15 → objutils-0.10.16}/objutils/image.py

@@ -689,13 +689,31 @@ class Image:
         """Write a numeric ASAM datatype with ECU byte order semantics."""
         self._call_address_function("write_asam_numeric", addr, value, dtype, byte_order, **kws)
 
-    def read_asam_string(self, addr: int, dtype: str, length: int = -1, **kws: Any) -> str:
-        """Read an ASAM string datatype (ASCII/UTF8/UTF16/UTF32)."""
-        return self._call_address_function("read_asam_string", addr, dtype, length, **kws)
+    def read_asam_string(self, addr: int, dtype: str, length: int = -1, encoding: str | None = None, **kws: Any) -> str:
+        """Read an ASAM string datatype (ASCII/UTF8/UTF16/UTF32).
 
-    def write_asam_string(self, addr: int, value: str, dtype: str, **kws: Any) -> None:
-        """Write an ASAM string datatype (ASCII/UTF8/UTF16/UTF32)."""
-        self._call_address_function("write_asam_string", addr, value, dtype, **kws)
+        Args:
+            addr: Absolute memory address to read from.
+            dtype: ASAM string datatype (``"ASCII"``, ``"UTF8"``, ``"UTF16"``, ``"UTF32"``).
+            length: Number of bytes, or ``-1`` for null-terminated (default: -1).
+            encoding: Optional Python codec name overriding the encoding implied by *dtype*
+                (e.g. ``"latin-1"``, ``"cp1252"``).  Useful when raw bytes cannot be decoded
+                with the standard ASAM mapping.
+        """
+        return self._call_address_function("read_asam_string", addr, dtype, length, encoding=encoding, **kws)
+
+    def write_asam_string(self, addr: int, value: str, dtype: str, encoding: str | None = None, **kws: Any) -> None:
+        """Write an ASAM string datatype (ASCII/UTF8/UTF16/UTF32).
+
+        Args:
+            addr: Absolute memory address to write to.
+            value: String to write.
+            dtype: ASAM string datatype (``"ASCII"``, ``"UTF8"``, ``"UTF16"``, ``"UTF32"``).
+            encoding: Optional Python codec name overriding the encoding implied by *dtype*
+                (e.g. ``"latin-1"``, ``"cp1252"``).  Useful when the string contains
+                characters outside the standard ASAM mapping.
+        """
+        self._call_address_function("write_asam_string", addr, value, dtype, encoding=encoding, **kws)
 
     def read_asam_numeric_array(
         self,

{objutils-0.10.15 → objutils-0.10.16}/objutils/registry.py

@@ -211,7 +211,6 @@ class CodecDoesNotExistError(Exception):
     """
 
 
-
 class CodecAlreadyExistError(Exception):
     """Raised when attempting to register a format that already exists.
 
@@ -230,7 +229,6 @@ class CodecAlreadyExistError(Exception):
     """
 
 
-
 class Codec(NamedTuple):
     """Container for format reader, writer, and metadata.
 

{objutils-0.10.15 → objutils-0.10.16}/objutils/section.py

@@ -917,35 +917,89 @@ class Section:
         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:
-            raise TypeError(f"Unsupported ASAM string datatype {dtype!r}")
-        if length == -1 and encoding in ("utf-8", "utf-16", "utf-32"):
+    def read_asam_string(self, addr: int, dtype: str, length: int = -1, encoding: str | None = None, **kws) -> str:
+        """Read an ASAM string from the section.
+
+        Args:
+            addr: Absolute memory address to read from.
+            dtype: ASAM string datatype (``"ASCII"``, ``"UTF8"``, ``"UTF16"``, ``"UTF32"``).
+            length: Number of bytes to read, or ``-1`` for null-terminated (default: -1).
+            encoding: Optional Python codec name that overrides the encoding implied by
+                *dtype* (e.g. ``"latin-1"``, ``"cp1252"``).  Use this when the raw bytes
+                cannot be decoded with the standard ASAM mapping – for example when an
+                embedded ECU stores a nominally-ASCII string with non-ASCII characters
+                such as ``b'\\xdc'`` (``Ü`` in Latin-1).  When *None* (default), the
+                encoding is derived from *dtype* as usual.
+
+        Returns:
+            Decoded string (without null terminator).
+
+        Raises:
+            InvalidAddressError: If address is out of bounds.
+            TypeError: If *dtype* is not a supported ASAM string type and no explicit
+                *encoding* is given, or if the string is not null-terminated.
+
+        Example::
+
+            raw = b'#MSV90-N52T\\xdc-B25-OL-F010-ULEV2-HGAG-LL-K'
+            sec = Section(0x1000, bytearray(raw) + b'\\x00')
+            # dtype="ASCII" alone would fail – override with latin-1:
+            text = sec.read_asam_string(0x1000, "ASCII", encoding="latin-1")
+            # text == '#MSV90-N52TÜ-B25-OL-F010-ULEV2-HGAG-LL-K'
+        """
+        if encoding is not None:
+            actual_encoding = encoding
+        else:
+            actual_encoding = ASAM_STRING_ENCODINGS.get(dtype.strip().upper())
+            if actual_encoding is None:
+                raise TypeError(f"Unsupported ASAM string datatype {dtype!r}")
+        if length == -1:
             offset = addr - self.start_address
             if offset < 0:
                 raise InvalidAddressError(f"read_asam_string(0x{addr:08x}) access out of bounds.")
             tail = self.data[offset:]
-            terminator = "\x00".encode(encoding=encoding)
+            terminator = "\x00".encode(encoding=actual_encoding)
             pos = tail.find(terminator)
             if pos != -1:
-                return tail[:pos].decode(encoding=encoding)
+                return tail[:pos].decode(encoding=actual_encoding)
             raise TypeError("Unterminated String!!!")
-        return self.read_string(addr, encoding=encoding, length=length, **kws)
-
-    def write_asam_string(self, addr: int, value: str, dtype: str, **kws) -> None:
-        encoding = ASAM_STRING_ENCODINGS.get(dtype.strip().upper())
-        if encoding is None:
-            raise TypeError(f"Unsupported ASAM string datatype {dtype!r}")
-        if encoding == "ascii":
-            self.write_string(addr, value, encoding=encoding, **kws)
-            return
+        return self.read_string(addr, encoding=actual_encoding, length=length, **kws)
+
+    def write_asam_string(self, addr: int, value: str, dtype: str, encoding: str | None = None, **kws) -> None:
+        """Write an ASAM string to the section with a null terminator.
+
+        Args:
+            addr: Absolute memory address to write to.
+            value: String to write.
+            dtype: ASAM string datatype (``"ASCII"``, ``"UTF8"``, ``"UTF16"``, ``"UTF32"``).
+            encoding: Optional Python codec name that overrides the encoding implied by
+                *dtype* (e.g. ``"latin-1"``, ``"cp1252"``).  Use this when the string
+                contains characters outside the standard ASAM mapping – for example
+                ``Ü`` (``\\xdc`` in Latin-1) in a nominally-ASCII field.  When *None*
+                (default), the encoding is derived from *dtype* as usual.
+
+        Raises:
+            InvalidAddressError: If address is out of bounds or write would exceed section.
+            TypeError: If *dtype* is not a supported ASAM string type and no explicit
+                *encoding* is given.
+
+        Example::
 
+            sec = Section(0x1000, bytearray(64))
+            text = '#MSV90-N52TÜ-B25-OL-F010-ULEV2-HGAG-LL-K'
+            sec.write_asam_string(0x1000, text, "ASCII", encoding="latin-1")
+        """
+        if encoding is not None:
+            actual_encoding = encoding
+        else:
+            actual_encoding = ASAM_STRING_ENCODINGS.get(dtype.strip().upper())
+            if actual_encoding is None:
+                raise TypeError(f"Unsupported ASAM string datatype {dtype!r}")
         offset = addr - self.start_address
         if offset < 0:
             raise InvalidAddressError(f"write_asam_string(0x{addr:08x}) access out of bounds.")
-        encoded = value.encode(encoding=encoding)
-        terminator = "\x00".encode(encoding=encoding)
+        encoded = value.encode(encoding=actual_encoding)
+        terminator = "\x00".encode(encoding=actual_encoding)
         total_length = len(encoded) + len(terminator)
         if offset + total_length > self.length:
             raise InvalidAddressError(f"write_asam_string(0x{addr:08x}) access out of bounds.")
@@ -1330,7 +1384,6 @@ def join_sections(sections: list[Section]) -> list[Section]:
     sorted_sections = sorted(sections, key=attrgetter("start_address"))
 
     for section in sorted_sections:
-
         if not result_sections:
             result_sections.append(Section(section.start_address, section.data))
             continue

{objutils-0.10.15 → objutils-0.10.16}/objutils/tests/test_section.py

@@ -1051,3 +1051,57 @@ def test_cross_numeric_array_to_ndarray_column_dir_3d():
     result = sec.read_asam_ndarray(0, 12, "UBYTE", shape=(3, 2, 2), index_mode="COLUMN_DIR", byte_order="MSB_LAST")
     assert result.shape == (2, 2, 3)
     assert np.array_equal(result, expected)
+
+
+# ---------------------------------------------------------------------------
+# ASAM string with custom encoding override
+# ---------------------------------------------------------------------------
+
+# Raw bytes from a real ECU that contain \xdc (Ü in Latin-1) but are stored
+# in a field declared as "ASCII".  Neither "ascii" nor "utf-8" can decode them.
+_LATIN1_RAW = b"#MSV90-N52T\xdc-B25-OL-F010-ULEV2-HGAG-LL-K"
+_LATIN1_STR = _LATIN1_RAW.decode("latin-1")  # '#MSV90-N52TÜ-B25-OL-F010-ULEV2-HGAG-LL-K'
+
+
+def test_read_asam_string_custom_encoding_latin1():
+    """read_asam_string with encoding='latin-1' decodes bytes that would fail as ASCII."""
+    data = bytearray(_LATIN1_RAW) + b"\x00"
+    sec = Section(start_address=0x1000, data=data)
+    result = sec.read_asam_string(0x1000, "ASCII", encoding="latin-1")
+    assert result == _LATIN1_STR
+
+
+def test_write_asam_string_custom_encoding_latin1():
+    """write_asam_string with encoding='latin-1' round-trips a string containing non-ASCII."""
+    sec = Section(start_address=0x1000, data=bytearray(64))
+    sec.write_asam_string(0x1000, _LATIN1_STR, "ASCII", encoding="latin-1")
+    raw = bytes(sec.data[: len(_LATIN1_RAW)])
+    assert raw == _LATIN1_RAW
+    # null terminator must follow immediately
+    assert sec.data[len(_LATIN1_RAW)] == 0
+
+
+def test_asam_string_encoding_roundtrip_latin1():
+    """Full write→read round-trip for a Latin-1 encoded ASAM ASCII string."""
+    sec = Section(start_address=0x2000, data=bytearray(64))
+    sec.write_asam_string(0x2000, _LATIN1_STR, "ASCII", encoding="latin-1")
+    result = sec.read_asam_string(0x2000, "ASCII", encoding="latin-1")
+    assert result == _LATIN1_STR
+
+
+def test_read_asam_string_ascii_still_works():
+    """Existing ASCII behaviour (no custom encoding) is not broken."""
+    text = "MOTOR"
+    data = bytearray(text, "ascii") + b"\x00"
+    sec = Section(start_address=0, data=bytearray(data) + bytearray(16))
+    result = sec.read_asam_string(0, "ASCII")
+    assert result == text
+
+
+def test_write_asam_string_utf8_still_works():
+    """Existing UTF8 behaviour (no custom encoding) is not broken."""
+    text = "Drehzahl"
+    sec = Section(start_address=0, data=bytearray(64))
+    sec.write_asam_string(0, text, "UTF8")
+    result = sec.read_asam_string(0, "UTF8")
+    assert result == text

{objutils-0.10.15 → objutils-0.10.16}/objutils/version.py

@@ -1,3 +1,3 @@
 """objutils version module"""
 
-__version__ = "0.10.15"
+__version__ = "0.10.16"

{objutils-0.10.15 → objutils-0.10.16}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "scikit_build_core.build"
 
 [project]
 name = "objutils"
-version = "0.10.15"
+version = "0.10.16"
 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.15"
+current_version = "0.10.16"
 version_pattern = "MAJOR.MINOR.PATCH"
 commit_message = "bump version {old_version} -> {new_version}"
 commit = true