objutils 0.10.0__tar.gz → 0.10.2__tar.gz

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

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

{objutils-0.10.0 → 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.0"
+__version__ = "0.10.2"
 
 __all__ = [
     "Image",
@@ -125,7 +125,7 @@ registry.register("ash", objutils.ash.Reader, objutils.ash.Writer, "ASCII hex sp
 registry.register("shf", objutils.shf.Reader, objutils.shf.Writer, "S Hexdump Format (rfc4149).")
 
 
-def load(codec_name: str, fp: str | Path | BinaryIO, join: bool = False, **kws: Any) -> Image:
+def load(codec_name: str, fp: str | Path | BinaryIO, join: bool = True, **kws: Any) -> Image:
     """Load hex data from file.
 
     Parameters
@@ -140,7 +140,7 @@ def load(codec_name: str, fp: str | Path | BinaryIO, join: bool = False, **kws:
     return registry.get(codec_name).Reader().load(fp, join=join, **kws)
 
 
-def loads(codec_name: str, data: str | bytes | bytearray, join: bool = False, **kws: Any) -> Image:
+def loads(codec_name: str, data: str | bytes | bytearray, join: bool = True, **kws: Any) -> Image:
     """Load hex data from bytes.
 
     Parameters

{objutils-0.10.0 → objutils-0.10.2}/objutils/fpc.py

@@ -108,7 +108,7 @@ class Reader(hexfile.Reader):
             out_lines.append("".join(values))
         return "\n".join(out_lines)
 
-    def read(self, fp: BinaryIO) -> Image:
+    def read(self, fp: BinaryIO, join: bool = False) -> Image:
         """Read FPC file and convert to Image.
 
         Args:
@@ -117,7 +117,7 @@ class Reader(hexfile.Reader):
         Returns:
             Image object containing decoded sections
         """
-        return super().read(create_string_buffer(bytearray(self.decode(fp), "ascii")))
+        return super().read(create_string_buffer(bytearray(self.decode(fp), "ascii")), join=join)
 
     def convert_quintuple(self, quintuple: str) -> int:
         """Convert 5-character base-85 quintuple to 32-bit integer.

{objutils-0.10.0 → objutils-0.10.2}/objutils/hexfile.py

@@ -499,16 +499,21 @@ class FormatParser:
 # ============================================================================
 
 
+@dataclass
 class Container:
-    """Legacy dynamic attribute container.
-
-    Deprecated: Use ParsedRecord instead.
-    """
+    """Modern attribute container for parsed hex records."""
 
-    def __init__(self) -> None:
-        self.processing_instructions: list[Any] = []
+    line_number: int = 0
+    address: Optional[int] = None
+    length: Optional[int] = None
+    type: Optional[int] = None
+    checksum: Optional[int] = None
+    chunk: Optional[bytearray] = None
+    junk: Optional[str] = None
+    processing_instructions: list[Any] = field(default_factory=list)
 
     def add_processing_instruction(self, pi: Any) -> None:
+        """Add a processing instruction to the record."""
         self.processing_instructions.append(pi)
 
 
@@ -785,6 +790,7 @@ class Reader(BaseType):
         self.stats = Statistics()
         self.valid = True
         self.formats: list[tuple[int, re.Pattern[str]]] = []
+        self.base_address = 0   # Base address for relative addressing (if applicable - mainly Intel HEX)
 
         # Parse FORMAT_SPEC into compiled patterns
         if isinstance(self.FORMAT_SPEC, str):
@@ -831,6 +837,21 @@ class Reader(BaseType):
             buffer = create_string_buffer(image)
         return self.load(buffer, join=join)
 
+    def _parse_optional_int(self, groups: dict[str, Optional[str]], key: str) -> Optional[int]:
+        """Parse an optional numeric capture group using ``atoi``.
+
+        Args:
+            groups: Regex named groups from a parsed line.
+            key: Group name to parse.
+
+        Returns:
+            Parsed integer or ``None`` if the group is missing/empty.
+        """
+        value = groups.get(key)
+        if value is None or value == "":
+            return None
+        return atoi(value)
+
     def read(self, fp: BinaryIO, join: bool = False) -> Image:
         """Read and parse hex file.
 
@@ -860,25 +881,23 @@ class Reader(BaseType):
                     continue
 
                 matched = True
-                container = Container()
-                container.line_number = line_number
-                dict_ = match.groupdict()
+                dict_: dict[str, Optional[str]] = match.groupdict()
 
                 if not dict_:
                     continue
 
                 self.stats.record_types[format_type] += 1
 
-                # Parse scalar values (address, length, type, checksum)
-                for key, value in dict_.items():
-                    if key not in ("chunk", "junk"):
-                        setattr(container, key, atoi(value))
-                    elif key == "junk":
-                        setattr(container, key, value)
+                address = self._parse_optional_int(dict_, "address")
+                length = self._parse_optional_int(dict_, "length")
+                record_type = self._parse_optional_int(dict_, "type")
+                checksum = self._parse_optional_int(dict_, "checksum")
+                junk = dict_.get("junk")
 
                 # Parse data chunk
-                if "chunk" in dict_:
-                    chunk_str = dict_["chunk"]
+                chunk: Optional[bytearray] = None
+                chunk_str = dict_.get("chunk")
+                if chunk_str is not None:
                     if self.DATA_SEPARATOR:
                         chunk_str = chunk_str.replace(self.DATA_SEPARATOR, "")
 
@@ -886,7 +905,16 @@ class Reader(BaseType):
                     if chunk_str:
                         for idx in range(0, len(chunk_str), 2):
                             chunk.append(atoi(chunk_str[idx : idx + 2]))
-                    container.chunk = chunk
+
+                container = Container(
+                    line_number=line_number,
+                    address=address,
+                    length=length,
+                    type=record_type,
+                    checksum=checksum,
+                    chunk=chunk,
+                    junk=junk,
+                )
 
                 # Validate line
                 self.check_line(container, format_type)
@@ -894,8 +922,8 @@ class Reader(BaseType):
                 # Process data lines
                 if self.is_data_line(container, format_type):
                     if self.parseData(container, format_type):
-                        address = getattr(container, "address", 0)
-                        chunk = getattr(container, "chunk", bytearray())
+                        address = (container.address if container.address is not None else 0) + self.base_address
+                        chunk = container.chunk if container.chunk is not None else bytearray()
                         self.stats.data_bytes[format_type] += len(chunk)
                         section = Section(address, chunk)
                         sections.append(section)
@@ -908,8 +936,8 @@ class Reader(BaseType):
                     meta_data[format_type].append(
                         MetaRecord(
                             format_type=format_type,
-                            address=getattr(container, "address", None),
-                            chunk=getattr(container, "chunk", None),
+                            address=container.address,
+                            chunk=container.chunk,
                         )
                     )
                 break  # Pattern matched, stop trying formats

{objutils-0.10.0 → objutils-0.10.2}/objutils/ihex.py

@@ -56,19 +56,6 @@ class Reader(hexfile.Reader):
     def __init__(self) -> None:
         """Initialize reader with address calculation state."""
         super().__init__()
-        self.segmentAddress: int = 0
-        self._address_calculator: Callable[[int], int] = self._default_address_calculator
-
-    def _default_address_calculator(self, x: int) -> int:
-        """Default address calculator (identity function).
-
-        Args:
-            x: Input address
-
-        Returns:
-            Same address unchanged
-        """
-        return x
 
     def check_line(self, line: Any, format_type: int) -> None:
         """Validate Intel HEX record checksum.
@@ -106,7 +93,7 @@ class Reader(hexfile.Reader):
         """
         return line.type == DATA
 
-    def calculate_extended_address(self, line: Any, shift_by: int, name: str) -> None:
+    def calculate_base_address(self, line: Any, shift_by: int, name: str) -> None:
         """Calculate extended address from segment/linear address record.
 
         Args:
@@ -118,9 +105,7 @@ class Reader(hexfile.Reader):
             # Extract 16-bit segment value
             segment = (line.chunk[0] << 8) | line.chunk[1]
             line.add_processing_instruction(("segment", segment))
-
-            # Update address calculator to add segment base
-            self._address_calculator = partial(operator.add, segment << shift_by)
+            self.base_address = segment << shift_by
             self.debug(f"EXTENDED_{name.upper()}_ADDRESS: {segment:#X}")
         else:
             self.error(f"Bad Extended {name} Address at line #{line.line_number}.")
@@ -135,43 +120,36 @@ class Reader(hexfile.Reader):
         Note:
             Handles extended addressing, start addresses, and EOF records.
         """
-        if line.type == DATA:
-            # Apply extended address calculation
-            line.address = self._address_calculator(line.address)
-
-        elif line.type == EXTENDED_SEGMENT_ADDRESS:
+        if line.type == EXTENDED_SEGMENT_ADDRESS:
             # Extended segment address (20-bit: segment << 4)
-            self.calculate_extended_address(line, 4, "Segment")
-
+            self.calculate_base_address(line, 4, "Segment")
         elif line.type == START_SEGMENT_ADDRESS:
             # Start segment address (CS:IP for x86)
             if len(line.chunk) == 4:
                 cs = (line.chunk[0] << 8) | line.chunk[1]
                 ip = (line.chunk[2] << 8) | line.chunk[3]
+                self.base_address = (cs << 4) + ip
                 line.add_processing_instruction(("cs", cs))
                 line.add_processing_instruction(("ip", ip))
                 self.debug(f"START_SEGMENT_ADDRESS: {hex(cs)}:{hex(ip)}")
             else:
                 self.error(f"Bad Segment Address at line #{line.line_number}.")
-
         elif line.type == EXTENDED_LINEAR_ADDRESS:
             # Extended linear address (32-bit: segment << 16)
-            self.calculate_extended_address(line, 16, "Linear")
-
+            self.calculate_base_address(line, 16, "Linear")
         elif line.type == START_LINEAR_ADDRESS:
             # Start linear address (EIP for x86)
             if len(line.chunk) == 4:
                 eip = (line.chunk[0] << 24) | (line.chunk[1] << 16) | (line.chunk[2] << 8) | line.chunk[3]
+                self.base_address = eip
                 line.add_processing_instruction(("eip", eip))
                 self.debug(f"START_LINEAR_ADDRESS: {hex(eip)}")
             else:
                 self.error(f"Bad Linear Address at line #{line.line_number}.")
-
         elif line.type == EOF:
             # End of file - nothing to process
             pass
-
-        else:
+        elif line.type != DATA:
             self.warn(f"Invalid record type [{line.type}] at line {line.line_number}")
 
 

{objutils-0.10.0 → 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.0 → objutils-0.10.2}/objutils/scripts/oj_hex_info.py

@@ -54,14 +54,6 @@ def main():
         default=False,
         help="Print filename including path",
     )
-    parser.add_argument(
-        "-j",
-        "--join-sections",
-        dest="join_section",
-        action="store_true",
-        default=False,
-        help="Join adjacent sections",
-    )
 
     args = parser.parse_args()
 
@@ -88,7 +80,7 @@ def main():
         print(f"Could not determine file type for '{hex_file}'.")
         sys.exit(1)
 
-    img = load(file_type.lower(), hex_file, join=args.join_section)
+    img = load(file_type.lower(), hex_file)
     if args.print_filename:
         print(f"\nFile: {hex_file}")
     print("\nSections")

{objutils-0.10.0 → 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
@@ -1029,11 +1122,10 @@ class LazySection(Section):
 
 
 def join_sections(sections: list[Section]) -> list[Section]:
-    """Join consecutive sections into contiguous blocks.
+    """Join sections when their address ranges are compatible.
 
-    Merges sections that are adjacent in memory (where one section's end address
-    equals the next section's start address) into single sections. Non-consecutive
-    sections remain separate.
+    Merges sections that are adjacent in memory or overlap with identical bytes in
+    the shared range. Conflicting overlaps remain separate sections.
 
     The function sorts sections by start address before processing.
 
@@ -1041,7 +1133,7 @@ def join_sections(sections: list[Section]) -> list[Section]:
         sections: List of Section objects to join
 
     Returns:
-        New list of Section objects with consecutive sections merged
+        New list of Section objects with compatible sections merged
 
     Raises:
         TypeError: If any element is not a Section instance
@@ -1068,20 +1160,46 @@ def join_sections(sections: list[Section]) -> list[Section]:
         This function is automatically called when creating an Image with
         ``join=True`` parameter.
     """
-    result_sections = []
-    sections.sort(key=attrgetter("start_address"))
-    prev_section = Section()
+    result_sections: list[Section] = []
     for section in sections:
         if not isinstance(section, Section):
             raise TypeError("'{}' is not a 'Section' instance", section)
-        if section.start_address == prev_section.start_address + prev_section.length and result_sections:
-            last_segment = result_sections[-1]
+
+    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
+
+        last_segment = result_sections[-1]
+        last_end = last_segment.start_address + last_segment.length
+        section_start = section.start_address
+        section_end = section_start + section.length
+
+        if section_start > last_end:
+            result_sections.append(Section(section.start_address, section.data))
+            continue
+
+        if section_start == last_end:
             last_segment.data.extend(section.data)
-        else:
-            # Create a new section.
+            continue
+
+        overlap_start = section_start
+        overlap_end = min(last_end, section_end)
+        overlap_length = overlap_end - overlap_start
+        last_offset = overlap_start - last_segment.start_address
+        section_offset = overlap_start - section_start
+
+        last_overlap = last_segment.data[last_offset : last_offset + overlap_length]
+        section_overlap = section.data[section_offset : section_offset + overlap_length]
+        if last_overlap != section_overlap:
             result_sections.append(Section(section.start_address, section.data))
-        prev_section = section
-    if result_sections:
-        return result_sections
-    else:
-        return []
+            continue
+
+        if section_end > last_end:
+            tail_offset = overlap_end - section_start
+            last_segment.data.extend(section.data[tail_offset:])
+
+    return result_sections

{objutils-0.10.0 → objutils-0.10.2}/objutils/srec.py

@@ -95,7 +95,7 @@ class Reader(hexfile.Reader):
         (S9, "S9LLAAAACC"),
     )
 
-    def load(self, fp: Any, join: bool = False, **kws: Any) -> Any:
+    def load(self, fp: Any, join: bool = True, **kws: Any) -> Any:
         """Load and parse S-Record file.
 
         Args: