odxtools 10.2.0__py3-none-any.whl → 10.3.0__py3-none-any.whl

odxtools/cli/browse.py

@@ -255,8 +255,10 @@ def encode_message_from_string_values(
                     print(f"The value specified for parameter {inner_param_sn} is not a string")
                     continue
 
-                typed_dict[inner_param_sn] = _convert_string_to_odx_type(
-                    inner_param_value, inner_param.physical_type.base_data_type)
+                if isinstance(inner_param,
+                              ParameterWithDOP) and inner_param.physical_type is not None:
+                    typed_dict[inner_param_sn] = _convert_string_to_odx_type(
+                        inner_param_value, inner_param.physical_type.base_data_type)
             parameter_values[parameter.short_name] = typed_dict
         else:
             if not isinstance(parameter_value, str):

odxtools/cli/compare.py

@@ -425,10 +425,10 @@ class Comparison(Display):
             changed_parameters_of_service=services_with_param_changes)
         dl1_service_names = [service.short_name for service in dl1.services]
 
-        dl1_request_prefixes: list[bytes | None] = [
+        dl1_request_prefixes: list[bytes | bytearray | None] = [
             None if s.request is None else s.request.coded_const_prefix() for s in dl1.services
         ]
-        dl2_request_prefixes: list[bytes | None] = [
+        dl2_request_prefixes: list[bytes | bytearray | None] = [
             None if s.request is None else s.request.coded_const_prefix() for s in dl2.services
         ]
 
@@ -436,7 +436,7 @@ class Comparison(Display):
         for service1 in dl1.services:
 
             # check for added diagnostic services
-            rq_prefix: bytes
+            rq_prefix: bytes | bytearray
             if service1.request is not None:
                 rq_prefix = service1.request.coded_const_prefix()
 

odxtools/compositecodec.py

@@ -79,7 +79,7 @@ def composite_codec_get_free_parameters(codec: CompositeCodec) -> list[Parameter
 
 
 def composite_codec_get_coded_const_prefix(codec: CompositeCodec,
-                                           request_prefix: bytes = b'') -> bytes:
+                                           request_prefix: bytes = b'') -> bytearray:
     encode_state = EncodeState(coded_message=bytearray(), triggering_request=request_prefix)
 
     for param in codec.parameters:

odxtools/configdata.py

@@ -0,0 +1,70 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass, field
+from typing import Any
+from xml.etree import ElementTree
+
+from .configrecord import ConfigRecord
+from .element import NamedElement
+from .nameditemlist import NamedItemList
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkId
+from .snrefcontext import SnRefContext
+from .specialdatagroup import SpecialDataGroup
+from .utils import dataclass_fields_asdict
+from .validbasevariant import ValidBaseVariant
+
+
+@dataclass(kw_only=True)
+class ConfigData(NamedElement):
+    """This class represents a CONFIG-DATA."""
+    valid_base_variants: list[ValidBaseVariant]
+    config_records: NamedItemList[ConfigRecord]
+    sdgs: list[SpecialDataGroup] = field(default_factory=list)
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "ConfigData":
+        kwargs = dataclass_fields_asdict(NamedElement.from_et(et_element, context))
+
+        valid_base_variants = [
+            ValidBaseVariant.from_et(vbv_elem, context)
+            for vbv_elem in et_element.iterfind("VALID-BASE-VARIANTS/VALID-BASE-VARIANT")
+        ]
+        config_records = NamedItemList([
+            ConfigRecord.from_et(cr_elem, context)
+            for cr_elem in et_element.iterfind("CONFIG-RECORDS/CONFIG-RECORD")
+        ])
+        sdgs = [SpecialDataGroup.from_et(sdge, context) for sdge in et_element.iterfind("SDGS/SDG")]
+
+        return ConfigData(
+            valid_base_variants=valid_base_variants,
+            config_records=config_records,
+            sdgs=sdgs,
+            **kwargs)
+
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
+        result = {}
+
+        for valid_base_variant in self.valid_base_variants:
+            result.update(valid_base_variant._build_odxlinks())
+        for config_record in self.config_records:
+            result.update(config_record._build_odxlinks())
+        for sdg in self.sdgs:
+            result.update(sdg._build_odxlinks())
+
+        return result
+
+    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
+        for valid_base_variant in self.valid_base_variants:
+            valid_base_variant._resolve_odxlinks(odxlinks)
+        for config_record in self.config_records:
+            config_record._resolve_odxlinks(odxlinks)
+        for sdg in self.sdgs:
+            sdg._resolve_odxlinks(odxlinks)
+
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
+        for valid_base_variant in self.valid_base_variants:
+            valid_base_variant._resolve_snrefs(context)
+        for config_record in self.config_records:
+            config_record._resolve_snrefs(context)
+        for sdg in self.sdgs:
+            sdg._resolve_snrefs(context)

odxtools/configdatadictionaryspec.py

@@ -0,0 +1,57 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass, field
+from typing import Any
+from xml.etree import ElementTree
+
+from .dataobjectproperty import DataObjectProperty
+from .nameditemlist import NamedItemList
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkId
+from .snrefcontext import SnRefContext
+from .unitspec import UnitSpec
+
+
+@dataclass(kw_only=True)
+class ConfigDataDictionarySpec:
+    data_object_props: NamedItemList[DataObjectProperty] = field(default_factory=NamedItemList)
+    unit_spec: UnitSpec | None = None
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element,
+                context: OdxDocContext) -> "ConfigDataDictionarySpec":
+        data_object_props = NamedItemList([
+            DataObjectProperty.from_et(dop_element, context)
+            for dop_element in et_element.iterfind("DATA-OBJECT-PROPS/DATA-OBJECT-PROP")
+        ])
+
+        if (spec_elem := et_element.find("UNIT-SPEC")) is not None:
+            unit_spec = UnitSpec.from_et(spec_elem, context)
+        else:
+            unit_spec = None
+
+        return ConfigDataDictionarySpec(
+            data_object_props=data_object_props,
+            unit_spec=unit_spec,
+        )
+
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
+        odxlinks = {}
+
+        for data_object_prop in self.data_object_props:
+            odxlinks.update(data_object_prop._build_odxlinks())
+        if self.unit_spec is not None:
+            odxlinks.update(self.unit_spec._build_odxlinks())
+
+        return odxlinks
+
+    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
+        for data_object_prop in self.data_object_props:
+            data_object_prop._resolve_odxlinks(odxlinks)
+        if self.unit_spec is not None:
+            self.unit_spec._resolve_odxlinks(odxlinks)
+
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
+        for data_object_prop in self.data_object_props:
+            data_object_prop._resolve_snrefs(context)
+        if self.unit_spec is not None:
+            self.unit_spec._resolve_snrefs(context)

odxtools/configiditem.py

@@ -0,0 +1,18 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass
+from xml.etree import ElementTree
+
+from .configitem import ConfigItem
+from .odxdoccontext import OdxDocContext
+from .utils import dataclass_fields_asdict
+
+
+@dataclass(kw_only=True)
+class ConfigIdItem(ConfigItem):
+    """This class represents a CONFIG-ID-ITEM."""
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "ConfigIdItem":
+        kwargs = dataclass_fields_asdict(ConfigItem.from_et(et_element, context))
+
+        return ConfigIdItem(**kwargs)

odxtools/configitem.py

@@ -0,0 +1,85 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass, field
+from typing import Any
+from xml.etree import ElementTree
+
+from .dopbase import DopBase
+from .element import NamedElement
+from .exceptions import odxrequire
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkId, OdxLinkRef, resolve_snref
+from .snrefcontext import SnRefContext
+from .specialdatagroup import SpecialDataGroup
+from .utils import dataclass_fields_asdict
+
+
+@dataclass(kw_only=True)
+class ConfigItem(NamedElement):
+    """This class represents a CONFIG-ITEM.
+
+    CONFIG-ITEM is the base class for CONFIG-ID-ITEM, DATA-ID-ITEM,
+    OPTION-ITEM, and SYSTEM-ITEM.
+    """
+    byte_position: int | None = None
+    bit_position: int | None = None
+
+    # according to the spec exactly one of the following two
+    # attributes is not None...x
+    data_object_prop_ref: OdxLinkRef | None = None
+    data_object_prop_snref: str | None = None
+    sdgs: list[SpecialDataGroup] = field(default_factory=list)
+
+    @property
+    def data_object_prop(self) -> DopBase:
+        return self._data_object_prop
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "ConfigItem":
+        kwargs = dataclass_fields_asdict(NamedElement.from_et(et_element, context))
+
+        byte_position = None
+        if (byte_pos_elem := et_element.findtext("BYTE-POSITION")) is not None:
+            byte_position = int(byte_pos_elem)
+
+        bit_position = None
+        if (bit_pos_elem := et_element.findtext("BIT-POSITION")) is not None:
+            bit_position = int(bit_pos_elem)
+
+        data_object_prop_ref = OdxLinkRef.from_et(et_element.find("DATA-OBJECT-PROP-REF"), context)
+        data_object_prop_snref = None
+        if (data_object_prop_snref_elem := et_element.find("DATA-OBJECT-PROP-SNREF")) is not None:
+            data_object_prop_snref = odxrequire(
+                data_object_prop_snref_elem.attrib.get("SHORT-NAME"))
+        sdgs = [SpecialDataGroup.from_et(sdge, context) for sdge in et_element.iterfind("SDGS/SDG")]
+
+        return ConfigItem(
+            byte_position=byte_position,
+            bit_position=bit_position,
+            data_object_prop_ref=data_object_prop_ref,
+            data_object_prop_snref=data_object_prop_snref,
+            sdgs=sdgs,
+            **kwargs)
+
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
+        result = {}
+
+        for sdg in self.sdgs:
+            result.update(sdg._build_odxlinks())
+
+        return result
+
+    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
+        if self.data_object_prop_ref is not None:
+            self._data_object_prop = odxlinks.resolve(self.data_object_prop_ref, DopBase)
+
+        for sdg in self.sdgs:
+            sdg._resolve_odxlinks(odxlinks)
+
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
+        if self.data_object_prop_snref is not None:
+            ddds = odxrequire(context.diag_layer).diag_data_dictionary_spec
+            self._data_object_prop = resolve_snref(self.data_object_prop_snref,
+                                                   ddds.all_data_object_properties, DopBase)
+
+        for sdg in self.sdgs:
+            sdg._resolve_snrefs(context)

odxtools/configrecord.py

@@ -0,0 +1,146 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass, field
+from typing import Any
+from xml.etree import ElementTree
+
+from .audience import Audience
+from .configiditem import ConfigIdItem
+from .dataiditem import DataIdItem
+from .datarecord import DataRecord
+from .diagcommdataconnector import DiagCommDataConnector
+from .element import NamedElement
+from .exceptions import odxrequire
+from .identvalue import IdentValue
+from .nameditemlist import NamedItemList
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkId
+from .optionitem import OptionItem
+from .snrefcontext import SnRefContext
+from .specialdatagroup import SpecialDataGroup
+from .systemitem import SystemItem
+from .utils import dataclass_fields_asdict
+
+
+@dataclass(kw_only=True)
+class ConfigRecord(NamedElement):
+    """This class represents a CONFIG-RECORD."""
+    config_id_item: ConfigIdItem | None = None
+    diag_comm_data_connectors: list[DiagCommDataConnector] = field(default_factory=list)
+    config_id: IdentValue | None = None
+    data_records: NamedItemList[DataRecord] = field(default_factory=NamedItemList)
+    audience: Audience | None = None
+    system_items: NamedItemList[SystemItem] = field(default_factory=NamedItemList)
+    data_id_item: DataIdItem | None = None
+    option_items: NamedItemList[OptionItem] = field(default_factory=NamedItemList)
+    default_data_record_snref: str | None = None
+    sdgs: list[SpecialDataGroup] = field(default_factory=list)
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "ConfigRecord":
+        kwargs = dataclass_fields_asdict(NamedElement.from_et(et_element, context))
+
+        config_id_item = None
+        if (cid_elem := et_element.find("CONFIG-ID-ITEM")) is not None:
+            config_id_item = ConfigIdItem.from_et(cid_elem, context)
+        diag_comm_data_connectors = [
+            DiagCommDataConnector.from_et(dcdc_elem, context) for dcdc_elem in et_element.iterfind(
+                "DIAG-COMM-DATA-CONNECTORS/DIAG-COMM-DATA-CONNECTOR")
+        ]
+        config_id = None
+        if (cid_elem := et_element.find("CONFIG-ID")) is not None:
+            config_id = IdentValue.from_et(cid_elem, context)
+        data_records = NamedItemList([
+            DataRecord.from_et(dr_elem, context)
+            for dr_elem in et_element.iterfind("DATA-RECORDS/DATA-RECORD")
+        ])
+        audience = None
+        if (aud_elem := et_element.find("AUDIENCE")) is not None:
+            audience = Audience.from_et(aud_elem, context)
+        system_items = NamedItemList([
+            SystemItem.from_et(si_elem, context)
+            for si_elem in et_element.iterfind("SYSTEM-ITEMS/SYSTEM-ITEM")
+        ])
+        data_id_item = None
+        if (dii_elem := et_element.find("DATA-ID-ITEM")) is not None:
+            data_id_item = DataIdItem.from_et(dii_elem, context)
+        option_items = NamedItemList([
+            OptionItem.from_et(si_elem, context)
+            for si_elem in et_element.iterfind("OPTION-ITEMS/OPTION-ITEM")
+        ])
+        default_data_record_snref = None
+        if (default_data_record_snref_elem :=
+                et_element.find("DEFAULT-DATA-RECORD-SNREF")) is not None:
+            default_data_record_snref = odxrequire(
+                default_data_record_snref_elem.attrib.get("SHORT-NAME"))
+        sdgs = [SpecialDataGroup.from_et(sdge, context) for sdge in et_element.iterfind("SDGS/SDG")]
+
+        return ConfigRecord(
+            config_id_item=config_id_item,
+            diag_comm_data_connectors=diag_comm_data_connectors,
+            config_id=config_id,
+            data_records=data_records,
+            audience=audience,
+            system_items=system_items,
+            data_id_item=data_id_item,
+            option_items=option_items,
+            default_data_record_snref=default_data_record_snref,
+            sdgs=sdgs,
+            **kwargs)
+
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
+        result = {}
+
+        if self.config_id_item is not None:
+            result.update(self.config_id_item._build_odxlinks())
+        for diag_comm_data_connector in self.diag_comm_data_connectors:
+            result.update(diag_comm_data_connector._build_odxlinks())
+        for data_record in self.data_records:
+            result.update(data_record._build_odxlinks())
+        if self.audience is not None:
+            result.update(self.audience._build_odxlinks())
+        for system_item in self.system_items:
+            result.update(system_item._build_odxlinks())
+        if self.data_id_item is not None:
+            result.update(self.data_id_item._build_odxlinks())
+        for option_item in self.option_items:
+            result.update(option_item._build_odxlinks())
+        for sdg in self.sdgs:
+            result.update(sdg._build_odxlinks())
+
+        return result
+
+    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
+        if self.config_id_item is not None:
+            self.config_id_item._resolve_odxlinks(odxlinks)
+        for diag_comm_data_connector in self.diag_comm_data_connectors:
+            diag_comm_data_connector._resolve_odxlinks(odxlinks)
+        for data_record in self.data_records:
+            data_record._resolve_odxlinks(odxlinks)
+        if self.audience is not None:
+            self.audience._resolve_odxlinks(odxlinks)
+        for system_item in self.system_items:
+            system_item._resolve_odxlinks(odxlinks)
+        if self.data_id_item is not None:
+            self.data_id_item._resolve_odxlinks(odxlinks)
+        for option_item in self.option_items:
+            option_item._resolve_odxlinks(odxlinks)
+        for sdg in self.sdgs:
+            sdg._resolve_odxlinks(odxlinks)
+
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
+        if self.config_id_item is not None:
+            self.config_id_item._resolve_snrefs(context)
+        for diag_comm_data_connector in self.diag_comm_data_connectors:
+            diag_comm_data_connector._resolve_snrefs(context)
+        for data_record in self.data_records:
+            data_record._resolve_snrefs(context)
+        if self.audience is not None:
+            self.audience._resolve_snrefs(context)
+        for system_item in self.system_items:
+            system_item._resolve_snrefs(context)
+        if self.data_id_item is not None:
+            self.data_id_item._resolve_snrefs(context)
+        for option_item in self.option_items:
+            option_item._resolve_snrefs(context)
+        for sdg in self.sdgs:
+            sdg._resolve_snrefs(context)

odxtools/database.py

@@ -18,6 +18,7 @@ from .diaglayers.ecushareddata import EcuSharedData
 from .diaglayers.ecuvariant import EcuVariant
 from .diaglayers.functionalgroup import FunctionalGroup
 from .diaglayers.protocol import Protocol
+from .ecuconfig import EcuConfig
 from .exceptions import odxraise, odxrequire
 from .flash import Flash
 from .nameditemlist import NamedItemList
@@ -40,6 +41,7 @@ class Database:
         self._diag_layer_containers = NamedItemList[DiagLayerContainer]()
         self._comparam_subsets = NamedItemList[ComparamSubset]()
         self._comparam_specs = NamedItemList[ComparamSpec]()
+        self._ecu_configs = NamedItemList[EcuConfig]()
         self._flashs = NamedItemList[Flash]()
         self._short_name = "odx_database"
 
@@ -114,6 +116,10 @@ class Database:
                 self._comparam_subsets.append(ComparamSubset.from_et(category_et, context))
             else:
                 self._comparam_specs.append(ComparamSpec.from_et(category_et, context))
+        elif category_tag == "ECU-CONFIG":
+            context = OdxDocContext(model_version,
+                                    (OdxDocFragment(category_sn, DocType.ECU_CONFIG),))
+            self._ecu_configs.append(EcuConfig.from_et(category_et, context))
         elif category_tag == "FLASH":
             context = OdxDocContext(model_version, (OdxDocFragment(category_sn, DocType.FLASH),))
             self._flashs.append(Flash.from_et(category_et, context))
@@ -148,6 +154,9 @@ class Database:
         for dlc in self.diag_layer_containers:
             dlc._resolve_odxlinks(self._odxlinks)
 
+        for ecu_config in self.ecu_configs:
+            ecu_config._resolve_odxlinks(self._odxlinks)
+
         for flash in self.flashs:
             flash._resolve_odxlinks(self._odxlinks)
 
@@ -163,6 +172,8 @@ class Database:
             spec._finalize_init(self, self._odxlinks)
         for dlc in self.diag_layer_containers:
             dlc._finalize_init(self, self._odxlinks)
+        for ecu_config in self.ecu_configs:
+            ecu_config._finalize_init(self, self._odxlinks)
         for flash in self.flashs:
             flash._finalize_init(self, self._odxlinks)
 
@@ -172,6 +183,8 @@ class Database:
             spec._resolve_snrefs(context)
         for dlc in self.diag_layer_containers:
             dlc._resolve_snrefs(context)
+        for ecu_config in self.ecu_configs:
+            ecu_config._resolve_snrefs(context)
         for flash in self.flashs:
             flash._resolve_snrefs(context)
 
@@ -187,6 +200,9 @@ class Database:
         for dlc in self.diag_layer_containers:
             result.update(dlc._build_odxlinks())
 
+        for ecu_config in self.ecu_configs:
+            result.update(ecu_config._build_odxlinks())
+
         for flash in self.flashs:
             result.update(flash._build_odxlinks())
 
@@ -263,6 +279,10 @@ class Database:
     def comparam_specs(self) -> NamedItemList[ComparamSpec]:
         return self._comparam_specs
 
+    @property
+    def ecu_configs(self) -> NamedItemList[EcuConfig]:
+        return self._ecu_configs
+
     @property
     def flashs(self) -> NamedItemList[Flash]:
         return self._flashs
@@ -274,4 +294,5 @@ class Database:
             f"diag_layer_containers={repr(self.diag_layer_containers)}, " \
             f"comparam_subsets={repr(self.comparam_subsets)}, " \
             f"comparam_specs={repr(self.comparam_specs)}, " \
+            f"ecu_configs={repr(self.ecu_configs)}, " \
             f"flashs={repr(self.flashs)})"

odxtools/dataiditem.py

@@ -0,0 +1,18 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass
+from xml.etree import ElementTree
+
+from .configitem import ConfigItem
+from .odxdoccontext import OdxDocContext
+from .utils import dataclass_fields_asdict
+
+
+@dataclass(kw_only=True)
+class DataIdItem(ConfigItem):
+    """This class represents a DATA-ID-ITEM."""
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "DataIdItem":
+        kwargs = dataclass_fields_asdict(ConfigItem.from_et(et_element, context))
+
+        return DataIdItem(**kwargs)

odxtools/datarecord.py

@@ -0,0 +1,132 @@
+# SPDX-License-Identifier: MIT
+import re
+from dataclasses import dataclass, field
+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 .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkId
+from .snrefcontext import SnRefContext
+from .specialdatagroup import SpecialDataGroup
+from .utils import dataclass_fields_asdict
+
+
+@dataclass(kw_only=True)
+class DataRecord(NamedElement):
+    rule: str | None = None
+    key: str | None = None
+    data_id: IdentValue | None = None
+    sdgs: list[SpecialDataGroup] = field(default_factory=list)
+
+    # at most one of the following two attributes is not None
+    datafile: Datafile | None = None
+    data: str | None = None
+
+    dataformat: DataformatSelection
+
+    @property
+    def dataset(self) -> BinFile | bytearray:
+        if self.datafile is not None:
+            db = odxrequire(self._database)
+            if db is None:
+                return bytearray()
+
+            datafile = odxrequire(self.datafile)
+            if datafile is None:
+                return bytearray()
+
+            aux_file = odxrequire(db.auxiliary_files.get(datafile.value))
+            if aux_file is None:
+                return bytearray()
+
+            data_str = aux_file.read().decode()
+            aux_file.seek(0)
+        elif self.data is not None:
+            data_str = self.data
+        else:
+            odxraise("No data specified for DATA-RECORD")
+            return bytearray()
+
+        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))
+
+        # user defined formats are not possible here
+        odxraise(f"Unsupported data format {self.dataformat.value}")
+        return bytearray()
+
+    @property
+    def blob(self) -> bytearray:
+        """Computes the binary data blob that ought to be send to the ECU.
+
+        i.e., this property stitches together the data of all
+        segments.
+
+        Note that, in order to reduce memory usage, this property is
+        not computed when instanting the data record object, but at
+        run time when it is accessed.
+        """
+
+        if isinstance(self.dataset, BinFile):
+            return cast(bytearray, self.dataset.as_binary())
+
+        return self.dataset
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "DataRecord":
+
+        kwargs = dataclass_fields_asdict(NamedElement.from_et(et_element, context))
+
+        rule = et_element.findtext("RULE")
+        key = et_element.findtext("KEY")
+        data_id = None
+        if (did_elem := et_element.find("DATA-ID")) is not None:
+            data_id = IdentValue.from_et(did_elem, context)
+        sdgs = [SpecialDataGroup.from_et(sdge, context) for sdge in et_element.iterfind("SDGS/SDG")]
+        datafile = None
+        if (df_elem := et_element.find("DATA-FILE")) is not None:
+            datafile = Datafile.from_et(df_elem, context)
+        data = et_element.findtext("DATA")
+
+        dataformat_str = odxrequire(et_element.attrib.get("DATAFORMAT"))
+        try:
+            dataformat = DataformatSelection(dataformat_str)
+        except ValueError:
+            dataformat = cast(DataformatSelection, None)
+            odxraise(f"Encountered unknown data format selection '{dataformat_str}'")
+
+        return DataRecord(
+            rule=rule,
+            key=key,
+            data_id=data_id,
+            sdgs=sdgs,
+            datafile=datafile,
+            data=data,
+            dataformat=dataformat,
+            **kwargs)
+
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
+        odxlinks: dict[OdxLinkId, Any] = {}
+
+        return odxlinks
+
+    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
+        pass
+
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
+        # this is slightly hacky because we only remember the
+        # applicable ODX database and do not resolve any SNREFs here
+        self._database = odxrequire(context.database)

odxtools/decodestate.py

@@ -21,7 +21,7 @@ class DecodeState:
     """Utility class to be used while decoding a message."""
 
     #: bytes to be decoded
-    coded_message: bytes
+    coded_message: bytes | bytearray
 
     #: Absolute position of the origin
     #: