Use the 'bincopy' python python module to handle MOTOROLA-S and INTEL-HEX data records and flash data

thanks to [at]kayoub5 for bringing this up.

Signed-off-by: Andreas Lauser <andreas.lauser@mercedes-benz.com>

Author: andlaus

odxtools/datarecord.py

@@ -1,17 +1,16 @@
 # SPDX-License-Identifier: MIT
 import re
 from dataclasses import dataclass, field
-from functools import cached_property
 from typing import Any, cast
 from xml.etree import ElementTree
 
+from bincopy import BinFile
+
 from .datafile import Datafile
 from .dataformatselection import DataformatSelection
 from .element import NamedElement
 from .exceptions import odxraise, odxrequire
 from .identvalue import IdentValue
-from .intelhexdataset import IntelHexDataSet
-from .motorolasdataset import MotorolaSDataSet
 from .odxdoccontext import OdxDocContext
 from .odxlink import OdxLinkDatabase, OdxLinkId
 from .snrefcontext import SnRefContext
@@ -32,9 +31,9 @@ class DataRecord(NamedElement):
 
     dataformat: DataformatSelection
 
-    @cached_property
-    def dataset(self) -> IntelHexDataSet | MotorolaSDataSet | bytearray:
-        if self.data is None:
+    @property
+    def dataset(self) -> BinFile | bytearray:
+        if self.datafile is not None:
             db = odxrequire(self._database)
             if db is None:
                 return bytearray()
@@ -55,10 +54,13 @@ def dataset(self) -> IntelHexDataSet | MotorolaSDataSet | bytearray:
             odxraise("No data specified for DATA-RECORD")
             return bytearray()
 
-        if self.dataformat == DataformatSelection.INTEL_HEX:
-            return IntelHexDataSet.from_string(data_str)
-        elif self.dataformat == DataformatSelection.MOTOROLA_S:
-            return MotorolaSDataSet.from_string(data_str)
+        if self.dataformat in (DataformatSelection.INTEL_HEX, DataformatSelection.MOTOROLA_S):
+            bf = BinFile()
+
+            # remove white space and empty lines
+            bf.add("\n".join([re.sub(r"\s", "", x) for x in data_str.splitlines() if x.strip()]))
+
+            return bf
         elif self.dataformat == DataformatSelection.BINARY:
             return bytearray.fromhex(re.sub(r"\s", "", data_str, flags=re.MULTILINE))
 
@@ -78,8 +80,8 @@ def blob(self) -> bytearray:
         run time when it is accessed.
         """
 
-        if isinstance(self.dataset, (IntelHexDataSet, MotorolaSDataSet)):
-            return self.dataset.blob
+        if isinstance(self.dataset, BinFile):
+            return cast(bytearray, self.dataset.as_binary())
 
         return self.dataset
 

odxtools/flashdata.py

@@ -1,16 +1,16 @@
 # SPDX-License-Identifier: MIT
 import re
 from dataclasses import dataclass
-from typing import Any
+from typing import Any, cast
 from xml.etree import ElementTree
 
+from bincopy import BinFile
+
 from .dataformat import Dataformat
 from .dataformatselection import DataformatSelection
 from .element import IdentifiableElement
 from .encryptcompressmethod import EncryptCompressMethod
-from .exceptions import odxassert, odxrequire
-from .intelhexdataset import IntelHexDataSet
-from .motorolasdataset import MotorolaSDataSet
+from .exceptions import odxassert, odxraise, odxrequire
 from .odxdoccontext import OdxDocContext
 from .odxlink import OdxLinkDatabase, OdxLinkId
 from .snrefcontext import SnRefContext
@@ -30,31 +30,33 @@ def data_str(self) -> str:
                                   f"by the {type(self).__name__} class")
 
     @property
-    def dataset(self) -> IntelHexDataSet | MotorolaSDataSet | bytearray | None:
+    def dataset(self) -> BinFile | bytearray | None:
         data_str = self.data_str
-        if self.dataformat.selection == DataformatSelection.INTEL_HEX:
-            return IntelHexDataSet.from_string(data_str)
-        elif self.dataformat.selection == DataformatSelection.MOTOROLA_S:
-            return MotorolaSDataSet.from_string(data_str)
+        if self.dataformat.selection in (DataformatSelection.INTEL_HEX,
+                                         DataformatSelection.MOTOROLA_S):
+            bf = BinFile()
+
+            # remove white space and empty lines
+            bf.add("\n".join([re.sub(r"\s", "", x) for x in data_str.splitlines() if x.strip()]))
+
+            return bf
         elif self.dataformat.selection == DataformatSelection.BINARY:
             return bytearray.fromhex(re.sub(r"\s", "", data_str, flags=re.MULTILINE))
         else:
-            odxassert(self.dataformat.selection == DataformatSelection.USER_DEFINED)
-            # user defined formats cannot be parsed on the odxtools
-            # level
+            odxassert(self.dataformat.selection == DataformatSelection.USER_DEFINED,
+                      f"Unsupported data format {self.dataformat.selection}")
             return None
 
     @property
-    def blob(self) -> bytearray | None:
+    def blob(self) -> bytearray:
         ds = self.dataset
-        if isinstance(ds, (IntelHexDataSet, MotorolaSDataSet)):
-            return ds.blob
+        if isinstance(ds, BinFile):
+            return cast(bytearray, ds.as_binary())
         elif isinstance(ds, bytearray):
             return ds
 
-        # USER-DEFINED flash data cannot be interpreted on the
-        # odxtools level
-        return ds
+        odxraise("USER-DEFINED flash data cannot be interpreted on the odxtools level")
+        return bytearray()
 
     @staticmethod
     def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "Flashdata":