odxtools 10.2.1__py3-none-any.whl → 10.4.0__py3-none-any.whl

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
     #:

odxtools/diagcommdataconnector.py

@@ -0,0 +1,61 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass
+from typing import Any
+from xml.etree import ElementTree
+
+from .exceptions import odxrequire
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkId
+from .readdiagcommconnector import ReadDiagCommConnector
+from .snrefcontext import SnRefContext
+from .utils import read_hex_binary
+from .writediagcommconnector import WriteDiagCommConnector
+
+
+@dataclass(kw_only=True)
+class DiagCommDataConnector:
+    uncompressed_size: int
+    source_start_address: int
+    read_diag_comm_connector: ReadDiagCommConnector | None = None
+    write_diag_comm_connector: WriteDiagCommConnector | None = None
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "DiagCommDataConnector":
+        uncompressed_size = int(odxrequire(et_element.findtext("UNCOMPRESSED-SIZE")))
+        source_start_address = odxrequire(read_hex_binary(et_element.find("SOURCE-START-ADDRESS")))
+
+        read_diag_comm_connector = None
+        if (rdcc_elem := et_element.find("READ-DIAG-COMM-CONNECTOR")) is not None:
+            read_diag_comm_connector = ReadDiagCommConnector.from_et(rdcc_elem, context)
+
+        write_diag_comm_connector = None
+        if (wdcc_elem := et_element.find("WRITE-DIAG-COMM-CONNECTOR")) is not None:
+            write_diag_comm_connector = WriteDiagCommConnector.from_et(wdcc_elem, context)
+
+        return DiagCommDataConnector(
+            uncompressed_size=uncompressed_size,
+            source_start_address=source_start_address,
+            read_diag_comm_connector=read_diag_comm_connector,
+            write_diag_comm_connector=write_diag_comm_connector)
+
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
+        odxlinks = {}
+
+        if self.read_diag_comm_connector is not None:
+            odxlinks.update(self.read_diag_comm_connector._build_odxlinks())
+        if self.write_diag_comm_connector is not None:
+            odxlinks.update(self.write_diag_comm_connector._build_odxlinks())
+
+        return odxlinks
+
+    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
+        if self.read_diag_comm_connector is not None:
+            self.read_diag_comm_connector._resolve_odxlinks(odxlinks)
+        if self.write_diag_comm_connector is not None:
+            self.write_diag_comm_connector._resolve_odxlinks(odxlinks)
+
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
+        if self.read_diag_comm_connector is not None:
+            self.read_diag_comm_connector._resolve_snrefs(context)
+        if self.write_diag_comm_connector is not None:
+            self.write_diag_comm_connector._resolve_snrefs(context)

odxtools/diaglayers/diaglayer.py

@@ -98,14 +98,7 @@ class DiagLayer:
         if self.import_refs:
             imported_links: dict[OdxLinkId, Any] = {}
             for import_ref in self.import_refs:
-                imported_dl = odxlinks.resolve(import_ref, DiagLayer)
-
-                odxassert(
-                    imported_dl.variant_type == DiagLayerType.ECU_SHARED_DATA,
-                    f"Tried to import references from diagnostic layer "
-                    f"'{imported_dl.short_name}' of type {imported_dl.variant_type.value}. "
-                    f"Only ECU-SHARED-DATA layers may be referenced using the "
-                    f"IMPORT-REF mechanism")
+                imported_dl = odxlinks.resolve(import_ref)
 
                 # TODO: ensure that the imported diagnostic layer has
                 # not been referenced in any PARENT-REF of the current
@@ -352,7 +345,7 @@ class DiagLayer:
             # corresponding request for `decode_response()`.)
             request_prefix = b''
             if s.request is not None:
-                request_prefix = s.request.coded_const_prefix()
+                request_prefix = bytes(s.request.coded_const_prefix())
             prefixes = [request_prefix]
             gnrs = getattr(self, "global_negative_responses", [])
             prefixes += [
@@ -383,7 +376,7 @@ class DiagLayer:
         else:
             cast(list[DiagService], sub_tree[-1]).append(service)
 
-    def _find_services_for_uds(self, message: bytes) -> list[DiagService]:
+    def _find_services_for_uds(self, message: bytes | bytearray) -> list[DiagService]:
         prefix_tree = self._prefix_tree
 
         # Find matching service(s) in prefix tree
@@ -398,7 +391,8 @@ class DiagLayer:
                 possible_services += cast(list[DiagService], prefix_tree[-1])
         return possible_services
 
-    def _decode(self, message: bytes, candidate_services: Iterable[DiagService]) -> list[Message]:
+    def _decode(self, message: bytes | bytearray,
+                candidate_services: Iterable[DiagService]) -> list[Message]:
         decoded_messages: list[Message] = []
 
         for service in candidate_services:
@@ -420,7 +414,7 @@ class DiagLayer:
 
                         decoded_messages.append(
                             Message(
-                                coded_message=message,
+                                coded_message=bytes(message),
                                 service=service,
                                 coding_object=gnr,
                                 param_dict=decoded_gnr))
@@ -437,12 +431,13 @@ class DiagLayer:
 
         return decoded_messages
 
-    def decode(self, message: bytes) -> list[Message]:
+    def decode(self, message: bytes | bytearray) -> list[Message]:
         candidate_services = self._find_services_for_uds(message)
 
         return self._decode(message, candidate_services)
 
-    def decode_response(self, response: bytes, request: bytes) -> list[Message]:
+    def decode_response(self, response: bytes | bytearray,
+                        request: bytes | bytearray) -> list[Message]:
         candidate_services = self._find_services_for_uds(request)
         if candidate_services is None:
             raise DecodeError(f"Couldn't find corresponding service for request {request.hex()}.")

odxtools/diagservice.py

@@ -179,13 +179,13 @@ class DiagService(DiagComm):
 
         self.request.print_free_parameters_info()
 
-    def decode_message(self, raw_message: bytes) -> Message:
+    def decode_message(self, raw_message: bytes | bytearray) -> Message:
         request_prefix = b''
         candidate_coding_objects: list[Request | Response] = [
             *self.positive_responses, *self.negative_responses
         ]
         if self.request is not None:
-            request_prefix = self.request.coded_const_prefix()
+            request_prefix = bytes(self.request.coded_const_prefix())
             candidate_coding_objects.append(self.request)
 
         coding_objects: list[Request | Response] = []
@@ -199,7 +199,7 @@ class DiagService(DiagComm):
             try:
                 result_list.append(
                     Message(
-                        coded_message=raw_message,
+                        coded_message=bytes(raw_message),
                         service=self,
                         coding_object=coding_object,
                         param_dict=coding_object.decode(raw_message)))
@@ -221,7 +221,7 @@ class DiagService(DiagComm):
 
         return result_list[0]
 
-    def encode_request(self, **kwargs: ParameterValue) -> bytes:
+    def encode_request(self, **kwargs: ParameterValue) -> bytearray:
         """Prepare an array of bytes ready to be send over the wire
         for the request of this service.
         """
@@ -229,7 +229,7 @@ class DiagService(DiagComm):
         # encoding are specified (parameters which have a default are
         # optional)
         if self.request is None:
-            return b''
+            return bytearray()
 
         missing_params = {x.short_name
                           for x in self.request.required_parameters}.difference(kwargs.keys())
@@ -245,18 +245,18 @@ class DiagService(DiagComm):
         return self.request.encode(**kwargs)
 
     def encode_positive_response(self,
-                                 coded_request: bytes,
+                                 coded_request: bytes | bytearray,
                                  response_index: int = 0,
-                                 **kwargs: ParameterValue) -> bytes:
+                                 **kwargs: ParameterValue) -> bytearray:
         # TODO: Should the user decide the positive response or what are the differences?
         return self.positive_responses[response_index].encode(coded_request, **kwargs)
 
     def encode_negative_response(self,
-                                 coded_request: bytes,
+                                 coded_request: bytes | bytearray,
                                  response_index: int = 0,
-                                 **kwargs: ParameterValue) -> bytes:
+                                 **kwargs: ParameterValue) -> bytearray:
         return self.negative_responses[response_index].encode(coded_request, **kwargs)
 
-    def __call__(self, **kwargs: ParameterValue) -> bytes:
+    def __call__(self, **kwargs: ParameterValue) -> bytearray:
         """Encode a request."""
         return self.encode_request(**kwargs)

odxtools/ecuconfig.py

@@ -0,0 +1,89 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any
+from xml.etree import ElementTree
+
+from .additionalaudience import AdditionalAudience
+from .configdata import ConfigData
+from .configdatadictionaryspec import ConfigDataDictionarySpec
+from .nameditemlist import NamedItemList
+from .odxcategory import OdxCategory
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkId
+from .snrefcontext import SnRefContext
+from .utils import dataclass_fields_asdict
+
+if TYPE_CHECKING:
+    from .database import Database
+
+
+@dataclass(kw_only=True)
+class EcuConfig(OdxCategory):
+    config_datas: NamedItemList[ConfigData]
+    additional_audiences: NamedItemList[AdditionalAudience]
+    config_data_dictionary_spec: ConfigDataDictionarySpec | None
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "EcuConfig":
+
+        base_obj = OdxCategory.from_et(et_element, context)
+        kwargs = dataclass_fields_asdict(base_obj)
+
+        config_datas = NamedItemList([
+            ConfigData.from_et(el, context)
+            for el in et_element.iterfind("CONFIG-DATAS/CONFIG-DATA")
+        ])
+        additional_audiences = NamedItemList([
+            AdditionalAudience.from_et(el, context)
+            for el in et_element.iterfind("ADDITIONAL-AUDIENCES/ADDITIONAL-AUDIENCE")
+        ])
+        config_data_dictionary_spec = None
+        if (cdd_elem := et_element.find("CONFIG-DATA-DICTIONARY-SPEC")) is not None:
+            config_data_dictionary_spec = ConfigDataDictionarySpec.from_et(cdd_elem, context)
+
+        return EcuConfig(
+            config_datas=config_datas,
+            additional_audiences=additional_audiences,
+            config_data_dictionary_spec=config_data_dictionary_spec,
+            **kwargs)
+
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
+        odxlinks = super()._build_odxlinks()
+
+        for config_data in self.config_datas:
+            odxlinks.update(config_data._build_odxlinks())
+
+        for additional_audience in self.additional_audiences:
+            odxlinks.update(additional_audience._build_odxlinks())
+
+        if self.config_data_dictionary_spec is not None:
+            odxlinks.update(self.config_data_dictionary_spec._build_odxlinks())
+
+        return odxlinks
+
+    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
+        super()._resolve_odxlinks(odxlinks)
+
+        for config_data in self.config_datas:
+            config_data._resolve_odxlinks(odxlinks)
+
+        for additional_audiences in self.additional_audiences:
+            additional_audiences._resolve_odxlinks(odxlinks)
+
+        if self.config_data_dictionary_spec is not None:
+            self.config_data_dictionary_spec._resolve_odxlinks(odxlinks)
+
+    def _finalize_init(self, database: "Database", odxlinks: OdxLinkDatabase) -> None:
+        super()._finalize_init(database, odxlinks)
+
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
+        super()._resolve_snrefs(context)
+
+        for config_data in self.config_datas:
+            config_data._resolve_snrefs(context)
+
+        for additional_audiences in self.additional_audiences:
+            additional_audiences._resolve_snrefs(context)
+
+        if self.config_data_dictionary_spec is not None:
+            self.config_data_dictionary_spec._resolve_snrefs(context)

odxtools/encryptcompressmethod.py

@@ -6,17 +6,26 @@ from .encryptcompressmethodtype import EncryptCompressMethodType
 from .exceptions import odxraise, odxrequire
 from .odxdoccontext import OdxDocContext
 from .odxlink import OdxLinkDatabase, OdxLinkId
+from .odxtypes import AtomicOdxType, DataType
 from .snrefcontext import SnRefContext
 
 
 @dataclass(kw_only=True)
 class EncryptCompressMethod:
-    value: str
+    value_raw: str
     value_type: EncryptCompressMethodType
 
+    @property
+    def value(self) -> AtomicOdxType:
+        return self._value
+
+    @property
+    def data_type(self) -> DataType:
+        return self._data_type
+
     @staticmethod
     def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "EncryptCompressMethod":
-        value = et_element.text or ""
+        value_raw = et_element.text or ""
 
         value_type_str = odxrequire(et_element.attrib.get("TYPE"))
         try:
@@ -25,7 +34,11 @@ class EncryptCompressMethod:
             value_type = cast(EncryptCompressMethodType, None)
             odxraise(f"Encountered unknown addressing type '{value_type_str}'")
 
-        return EncryptCompressMethod(value=value, value_type=value_type)
+        return EncryptCompressMethod(value_raw=value_raw, value_type=value_type)
+
+    def __post_init__(self) -> None:
+        self._data_type = DataType(self.value_type.value)
+        self._value = self._data_type.from_string(self.value_raw.strip())
 
     def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         odxlinks: dict[OdxLinkId, Any] = {}

odxtools/externflashdata.py

@@ -1,10 +1,10 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import Any
+from typing import IO, Any
 from xml.etree import ElementTree
 
 from .datafile import Datafile
-from .exceptions import odxrequire
+from .exceptions import odxraise, odxrequire
 from .flashdata import Flashdata
 from .odxdoccontext import OdxDocContext
 from .odxlink import OdxLinkDatabase, OdxLinkId
@@ -16,6 +16,21 @@ from .utils import dataclass_fields_asdict
 class ExternFlashdata(Flashdata):
     datafile: Datafile
 
+    @property
+    def data_str(self) -> str:
+        if self._database is None:
+            odxraise("No database object specified")
+            return ""
+
+        aux_file: IO[bytes] = odxrequire(self._database.auxiliary_files.get(self.datafile.value))
+        if aux_file is None:
+            return ""
+
+        result = aux_file.read().decode()
+        aux_file.seek(0)
+
+        return result
+
     @staticmethod
     def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "ExternFlashdata":
         kwargs = dataclass_fields_asdict(Flashdata.from_et(et_element, context))
@@ -32,3 +47,7 @@ class ExternFlashdata(Flashdata):
 
     def _resolve_snrefs(self, context: SnRefContext) -> None:
         super()._resolve_snrefs(context)
+
+        # this is slightly hacky because we only remember the
+        # applicable ODX database and do not resolve any SNREFs here
+        self._database = context.database

odxtools/flashdata.py

@@ -1,12 +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 odxrequire
+from .exceptions import odxassert, odxraise, odxrequire
 from .odxdoccontext import OdxDocContext
 from .odxlink import OdxLinkDatabase, OdxLinkId
 from .snrefcontext import SnRefContext
@@ -20,6 +24,40 @@ class Flashdata(IdentifiableElement):
     dataformat: Dataformat
     encrypt_compress_method: EncryptCompressMethod | None = None
 
+    @property
+    def data_str(self) -> str:
+        raise NotImplementedError(f"The .data_str property has not been implemented "
+                                  f"by the {type(self).__name__} class")
+
+    @property
+    def dataset(self) -> BinFile | bytearray | None:
+        data_str = self.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,
+                      f"Unsupported data format {self.dataformat.selection}")
+            return None
+
+    @property
+    def blob(self) -> bytearray:
+        ds = self.dataset
+        if isinstance(ds, BinFile):
+            return cast(bytearray, ds.as_binary())
+        elif isinstance(ds, bytearray):
+            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":
 

odxtools/identvalue.py

@@ -5,6 +5,7 @@ from xml.etree import ElementTree
 from .exceptions import odxraise
 from .identvaluetype import IdentValueType
 from .odxdoccontext import OdxDocContext
+from .odxtypes import AtomicOdxType, DataType
 
 
 @dataclass(kw_only=True)
@@ -13,15 +14,23 @@ class IdentValue:
     Corresponds to IDENT-VALUE.
     """
 
-    value: str
+    value_raw: str
 
     # note that the spec says this attribute is named "TYPE", but in
     # python, "type" is a build-in function...
     value_type: IdentValueType
 
+    @property
+    def value(self) -> AtomicOdxType:
+        return self._value
+
+    @property
+    def data_type(self) -> DataType:
+        return self._data_type
+
     @staticmethod
     def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "IdentValue":
-        value = et_element.text or ""
+        value_raw = et_element.text or ""
 
         try:
             value_type = IdentValueType(et_element.attrib["TYPE"])
@@ -29,4 +38,8 @@ class IdentValue:
             odxraise(f"Cannot parse IDENT-VALUE-TYPE: {e}")
             value_type = None
 
-        return IdentValue(value=value, value_type=value_type)
+        return IdentValue(value_raw=value_raw, value_type=value_type)
+
+    def __post_init__(self) -> None:
+        self._data_type = DataType(self.value_type.value)
+        self._value = self._data_type.from_string(self.value_raw.strip())

odxtools/internflashdata.py

@@ -15,6 +15,10 @@ from .utils import dataclass_fields_asdict
 class InternFlashdata(Flashdata):
     data: str
 
+    @property
+    def data_str(self) -> str:
+        return self.data
+
     @staticmethod
     def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "InternFlashdata":
         kwargs = dataclass_fields_asdict(Flashdata.from_et(et_element, context))