objutils 0.10.2__tar.gz → 0.10.3__tar.gz

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

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

{objutils-0.10.2 → 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.2"
+__version__ = "0.10.3"
 
 __all__ = [
     "Image",

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

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

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

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