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

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

@@ -7,6 +7,7 @@ from itertools import chain
 from typing import Any, Union, cast
 from xml.etree import ElementTree
 
+from ..additionalaudience import AdditionalAudience
 from ..admindata import AdminData
 from ..companydata import CompanyData
 from ..description import Description
@@ -14,6 +15,7 @@ from ..diagcomm import DiagComm
 from ..diagdatadictionaryspec import DiagDataDictionarySpec
 from ..diagservice import DiagService
 from ..exceptions import DecodeError, odxassert, odxraise
+from ..functionalclass import FunctionalClass
 from ..library import Library
 from ..message import Message
 from ..nameditemlist import NamedItemList, TNamed
@@ -26,6 +28,7 @@ from ..servicebinner import ServiceBinner
 from ..singleecujob import SingleEcuJob
 from ..snrefcontext import SnRefContext
 from ..specialdatagroup import SpecialDataGroup
+from ..statechart import StateChart
 from ..subcomponent import SubComponent
 from ..unitgroup import UnitGroup
 from .diaglayerraw import DiagLayerRaw
@@ -223,12 +226,30 @@ class DiagLayer:
     def admin_data(self) -> AdminData | None:
         return self.diag_layer_raw.admin_data
 
+    @property
+    def company_datas(self) -> NamedItemList[CompanyData]:
+        return self.diag_layer_raw.company_datas
+
+    @property
+    def functional_classes(self) -> NamedItemList[FunctionalClass]:
+        return self.diag_layer_raw.functional_classes
+
+    @property
+    def diag_data_dictionary_spec(self) -> DiagDataDictionarySpec:
+        """The DiagDataDictionarySpec applicable to this DiagLayer"""
+        return self._diag_data_dictionary_spec
+
+    @property
+    def diag_comms_raw(self) -> list[OdxLinkRef | DiagComm]:
+        return self.diag_layer_raw.diag_comms_raw
+
     @property
     def diag_comms(self) -> NamedItemList[DiagComm]:
         return self.diag_layer_raw.diag_comms
 
     @property
     def services(self) -> NamedItemList[DiagService]:
+        """This is an alias for `.diag_services`"""
         return self.diag_layer_raw.services
 
     @property
@@ -239,10 +260,6 @@ class DiagLayer:
     def single_ecu_jobs(self) -> NamedItemList[SingleEcuJob]:
         return self.diag_layer_raw.single_ecu_jobs
 
-    @property
-    def company_datas(self) -> NamedItemList[CompanyData]:
-        return self.diag_layer_raw.company_datas
-
     @property
     def requests(self) -> NamedItemList[Request]:
         return self.diag_layer_raw.requests
@@ -264,21 +281,24 @@ class DiagLayer:
         return self.diag_layer_raw.import_refs
 
     @property
-    def libraries(self) -> NamedItemList[Library]:
-        return self.diag_layer_raw.libraries
+    def state_charts(self) -> NamedItemList[StateChart]:
+        return self.diag_layer_raw.state_charts
+
+    @property
+    def additional_audiences(self) -> NamedItemList[AdditionalAudience]:
+        return self.diag_layer_raw.additional_audiences
 
     @property
     def sub_components(self) -> NamedItemList[SubComponent]:
         return self.diag_layer_raw.sub_components
 
     @property
-    def sdgs(self) -> list[SpecialDataGroup]:
-        return self.diag_layer_raw.sdgs
+    def libraries(self) -> NamedItemList[Library]:
+        return self.diag_layer_raw.libraries
 
     @property
-    def diag_data_dictionary_spec(self) -> DiagDataDictionarySpec:
-        """The DiagDataDictionarySpec applicable to this DiagLayer"""
-        return self._diag_data_dictionary_spec
+    def sdgs(self) -> list[SpecialDataGroup]:
+        return self.diag_layer_raw.sdgs
 
     #####
     # </properties forwarded to the "raw" diag layer>
@@ -332,7 +352,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 += [
@@ -363,7 +383,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
@@ -378,7 +398,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:
@@ -400,7 +421,7 @@ class DiagLayer:
 
                         decoded_messages.append(
                             Message(
-                                coded_message=message,
+                                coded_message=bytes(message),
                                 service=service,
                                 coding_object=gnr,
                                 param_dict=decoded_gnr))
@@ -417,12 +438,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/diaglayers/ecuvariant.py

@@ -33,6 +33,18 @@ class EcuVariant(HierarchyElement):
     def diag_variables_raw(self) -> list[DiagVariable | OdxLinkRef]:
         return self.ecu_variant_raw.diag_variables_raw
 
+    @property
+    def diag_variables(self) -> NamedItemList[DiagVariable]:
+        return self._diag_variables
+
+    @property
+    def variable_groups(self) -> NamedItemList[VariableGroup]:
+        return self._variable_groups
+
+    @property
+    def ecu_variant_patterns(self) -> list[EcuVariantPattern]:
+        return self.ecu_variant_raw.ecu_variant_patterns
+
     @property
     def dyn_defined_spec(self) -> DynDefinedSpec | None:
         return self.ecu_variant_raw.dyn_defined_spec
@@ -56,25 +68,6 @@ class EcuVariant(HierarchyElement):
 
         return None
 
-    @property
-    def ecu_variant_patterns(self) -> list[EcuVariantPattern]:
-        return self.ecu_variant_raw.ecu_variant_patterns
-
-    #######
-    # <properties subject to value inheritance>
-    #######
-    @property
-    def diag_variables(self) -> NamedItemList[DiagVariable]:
-        return self._diag_variables
-
-    @property
-    def variable_groups(self) -> NamedItemList[VariableGroup]:
-        return self._variable_groups
-
-    #######
-    # </properties subject to value inheritance>
-    #######
-
     @staticmethod
     def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "EcuVariant":
         ecu_variant_raw = EcuVariantRaw.from_et(et_element, context)

odxtools/diaglayers/hierarchyelement.py

@@ -438,6 +438,11 @@ class HierarchyElement(DiagLayer):
     #######
     # <properties subject to value inheritance>
     #######
+    @property
+    def functional_classes(self) -> NamedItemList[FunctionalClass]:
+        """All functional classes applicable to this DiagLayer"""
+        return self._functional_classes
+
     @property
     def diag_data_dictionary_spec(self) -> DiagDataDictionarySpec:
         return self._diag_data_dictionary_spec
@@ -480,11 +485,6 @@ class HierarchyElement(DiagLayer):
         """All global negative responses applicable to this DiagLayer"""
         return self._global_negative_responses
 
-    @property
-    def functional_classes(self) -> NamedItemList[FunctionalClass]:
-        """All functional classes applicable to this DiagLayer"""
-        return self._functional_classes
-
     @property
     def state_charts(self) -> NamedItemList[StateChart]:
         """All state charts applicable to this DiagLayer"""

odxtools/diaglayers/protocol.py

@@ -7,6 +7,8 @@ from xml.etree import ElementTree
 from ..comparamspec import ComparamSpec
 from ..exceptions import odxassert
 from ..odxdoccontext import OdxDocContext
+from ..odxlink import OdxLinkRef
+from ..parentref import ParentRef
 from ..protstack import ProtStack
 from .hierarchyelement import HierarchyElement
 from .protocolraw import ProtocolRaw
@@ -24,14 +26,26 @@ class Protocol(HierarchyElement):
     def protocol_raw(self) -> ProtocolRaw:
         return cast(ProtocolRaw, self.diag_layer_raw)
 
+    @property
+    def comparam_spec_ref(self) -> OdxLinkRef:
+        return self.protocol_raw.comparam_spec_ref
+
     @property
     def comparam_spec(self) -> ComparamSpec:
         return self.protocol_raw.comparam_spec
 
+    @property
+    def prot_stack_snref(self) -> str | None:
+        return self.protocol_raw.prot_stack_snref
+
     @property
     def prot_stack(self) -> ProtStack | None:
         return self.protocol_raw.prot_stack
 
+    @property
+    def parent_refs(self) -> list[ParentRef]:
+        return self.protocol_raw.parent_refs
+
     @staticmethod
     def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "Protocol":
         protocol_raw = ProtocolRaw.from_et(et_element, context)

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))