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

odxtools/ecumemconnector.py

@@ -0,0 +1,136 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass, field
+from typing import Any
+from xml.etree import ElementTree
+
+from .admindata import AdminData
+from .diaglayers.basevariant import BaseVariant
+from .diaglayers.ecuvariant import EcuVariant
+from .ecumem import EcuMem
+from .element import IdentifiableElement
+from .exceptions import odxraise, odxrequire
+from .flashclass import FlashClass
+from .identdesc import IdentDesc
+from .nameditemlist import NamedItemList
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkId, OdxLinkRef
+from .sessiondesc import SessionDesc
+from .snrefcontext import SnRefContext
+from .specialdatagroup import SpecialDataGroup
+from .utils import dataclass_fields_asdict
+
+
+@dataclass(kw_only=True)
+class EcuMemConnector(IdentifiableElement):
+    admin_data: AdminData | None = None
+    flash_classes: NamedItemList[FlashClass]
+    session_descs: NamedItemList[SessionDesc] = field(default_factory=NamedItemList)
+    ident_descs: list[IdentDesc] = field(default_factory=list)
+    ecu_mem_ref: OdxLinkRef
+    layer_refs: list[OdxLinkRef]
+    all_variant_refs: list[OdxLinkRef]
+    sdgs: list[SpecialDataGroup] = field(default_factory=list)
+
+    @property
+    def ecu_mem(self) -> EcuMem:
+        return self._ecu_mem
+
+    @property
+    def layers(self) -> NamedItemList[EcuVariant | BaseVariant]:
+        return self._layers
+
+    @property
+    def all_variants(self) -> NamedItemList[BaseVariant]:
+        return self._all_variants
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "EcuMemConnector":
+
+        kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, context))
+
+        admin_data = AdminData.from_et(et_element.find("ADMIN-DATA"), context)
+        flash_classes = NamedItemList([
+            FlashClass.from_et(el, context)
+            for el in et_element.iterfind("FLASH-CLASSS/FLASH-CLASS")
+        ])
+        session_descs = NamedItemList([
+            SessionDesc.from_et(el, context)
+            for el in et_element.iterfind("SESSION-DESCS/SESSION-DESC")
+        ])
+        ident_descs = [
+            IdentDesc.from_et(el, context) for el in et_element.iterfind("IDENT-DESCS/IDENT-DESC")
+        ]
+        ecu_mem_ref = OdxLinkRef.from_et(odxrequire(et_element.find("ECU-MEM-REF")), context)
+        layer_refs = [
+            OdxLinkRef.from_et(el, context) for el in et_element.iterfind("LAYER-REFS/LAYER-REF")
+        ]
+        all_variant_refs = [
+            OdxLinkRef.from_et(el, context)
+            for el in et_element.iterfind("ALL-VARIANT-REFS/ALL-VARIANT-REF")
+        ]
+        sdgs = [SpecialDataGroup.from_et(sdge, context) for sdge in et_element.iterfind("SDGS/SDG")]
+
+        return EcuMemConnector(
+            admin_data=admin_data,
+            flash_classes=flash_classes,
+            session_descs=session_descs,
+            ident_descs=ident_descs,
+            ecu_mem_ref=ecu_mem_ref,
+            layer_refs=layer_refs,
+            all_variant_refs=all_variant_refs,
+            sdgs=sdgs,
+            **kwargs)
+
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
+        odxlinks = {self.odx_id: self}
+
+        if self.admin_data is not None:
+            odxlinks.update(self.admin_data._build_odxlinks())
+        for flash_class in self.flash_classes:
+            odxlinks.update(flash_class._build_odxlinks())
+        for session_desc in self.session_descs:
+            odxlinks.update(session_desc._build_odxlinks())
+        for ident_desc in self.ident_descs:
+            odxlinks.update(ident_desc._build_odxlinks())
+        for sdg in self.sdgs:
+            odxlinks.update(sdg._build_odxlinks())
+
+        return odxlinks
+
+    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
+        self._ecu_mem = odxlinks.resolve(self.ecu_mem_ref, EcuMem)
+
+        tmp = []
+        for ref in self.layer_refs:
+            x = odxlinks.resolve(ref)
+            if not isinstance(x, (BaseVariant, EcuVariant)):
+                odxraise("Invalid type of referenced object")
+            tmp.append(x)
+        self._layers = NamedItemList(tmp)
+
+        self._all_variants = NamedItemList(
+            [odxlinks.resolve(ref, BaseVariant) for ref in self.all_variant_refs])
+        self._ecu_mem = odxlinks.resolve(self.ecu_mem_ref, EcuMem)
+
+        if self.admin_data is not None:
+            self.admin_data._resolve_odxlinks(odxlinks)
+        for flash_class in self.flash_classes:
+            flash_class._resolve_odxlinks(odxlinks)
+        for session_desc in self.session_descs:
+            session_desc._resolve_odxlinks(odxlinks)
+        for ident_desc in self.ident_descs:
+            ident_desc._resolve_odxlinks(odxlinks)
+        for sdg in self.sdgs:
+            sdg._resolve_odxlinks(odxlinks)
+
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
+        if self.admin_data is not None:
+            self.admin_data._resolve_snrefs(context)
+        for flash_class in self.flash_classes:
+            flash_class._resolve_snrefs(context)
+        for session_desc in self.session_descs:
+            session_desc._resolve_snrefs(context)
+        for ident_desc in self.ident_descs:
+            ident_desc._resolve_snrefs(context)
+        for sdg in self.sdgs:
+            sdg._resolve_snrefs(context)

odxtools/encryptcompressmethod.py

@@ -0,0 +1,39 @@
+from dataclasses import dataclass
+from typing import Any, cast
+from xml.etree import ElementTree
+
+from .encryptcompressmethodtype import EncryptCompressMethodType
+from .exceptions import odxraise, odxrequire
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkId
+from .snrefcontext import SnRefContext
+
+
+@dataclass(kw_only=True)
+class EncryptCompressMethod:
+    value: str
+    value_type: EncryptCompressMethodType
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "EncryptCompressMethod":
+        value = et_element.text or ""
+
+        value_type_str = odxrequire(et_element.attrib.get("TYPE"))
+        try:
+            value_type = EncryptCompressMethodType(value_type_str)
+        except ValueError:
+            value_type = cast(EncryptCompressMethodType, None)
+            odxraise(f"Encountered unknown addressing type '{value_type_str}'")
+
+        return EncryptCompressMethod(value=value, value_type=value_type)
+
+    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:
+        pass

odxtools/encryptcompressmethodtype.py

@@ -0,0 +1,13 @@
+# SPDX-License-Identifier: MIT
+from enum import Enum
+
+from .odxtypes import DataType
+
+
+class EncryptCompressMethodType(Enum):
+    A_UINT32 = "A_UINT32"
+    A_BYTEFIELD = "A_BYTEFIELD"
+
+    @property
+    def data_type(self) -> DataType:
+        return DataType(self.value)

odxtools/expectedident.py

@@ -0,0 +1,40 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass
+from typing import Any
+from xml.etree import ElementTree
+
+from .element import IdentifiableElement
+from .identvalue import IdentValue
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkId
+from .snrefcontext import SnRefContext
+from .utils import dataclass_fields_asdict
+
+
+@dataclass(kw_only=True)
+class ExpectedIdent(IdentifiableElement):
+    """
+    Corresponds to EXPECTED-IDENT.
+    """
+
+    ident_values: list[IdentValue]
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "ExpectedIdent":
+        kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, context))
+
+        ident_values = [
+            IdentValue.from_et(ive, context)
+            for ive in et_element.iterfind("IDENT-VALUES/IDENT-VALUE")
+        ]
+
+        return ExpectedIdent(ident_values=ident_values, **kwargs)
+
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
+        return {self.odx_id: self}
+
+    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
+        pass
+
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
+        pass

odxtools/externflashdata.py

@@ -0,0 +1,34 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass
+from typing import Any
+from xml.etree import ElementTree
+
+from .datafile import Datafile
+from .exceptions import odxrequire
+from .flashdata import Flashdata
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkId
+from .snrefcontext import SnRefContext
+from .utils import dataclass_fields_asdict
+
+
+@dataclass(kw_only=True)
+class ExternFlashdata(Flashdata):
+    datafile: Datafile
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "ExternFlashdata":
+        kwargs = dataclass_fields_asdict(Flashdata.from_et(et_element, context))
+
+        datafile = Datafile.from_et(odxrequire(et_element.find("DATAFILE")), context)
+
+        return ExternFlashdata(datafile=datafile, **kwargs)
+
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
+        return super()._build_odxlinks()
+
+    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
+        super()._resolve_odxlinks(odxlinks)
+
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
+        super()._resolve_snrefs(context)

odxtools/filter.py

@@ -0,0 +1,32 @@
+# 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 .snrefcontext import SnRefContext
+from .utils import read_hex_binary
+
+
+@dataclass(kw_only=True)
+class Filter:
+    filter_start: int
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "Filter":
+        filter_start = odxrequire(read_hex_binary(et_element.find("FILTER-START")))
+
+        return Filter(filter_start=filter_start)
+
+    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:
+        pass

odxtools/flash.py

@@ -0,0 +1,88 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, Any
+from xml.etree import ElementTree
+
+from .additionalaudience import AdditionalAudience
+from .ecumem import EcuMem
+from .ecumemconnector import EcuMemConnector
+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 Flash(OdxCategory):
+    ecu_mems: NamedItemList[EcuMem] = field(default_factory=NamedItemList)
+    ecu_mem_connectors: NamedItemList[EcuMemConnector] = field(default_factory=NamedItemList)
+    additional_audiences: NamedItemList[AdditionalAudience] = field(default_factory=NamedItemList)
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "Flash":
+
+        base_obj = OdxCategory.from_et(et_element, context)
+        kwargs = dataclass_fields_asdict(base_obj)
+
+        ecu_mems = NamedItemList(
+            [EcuMem.from_et(el, context) for el in et_element.iterfind("ECU-MEMS/ECU-MEM")])
+        ecu_mem_connectors = NamedItemList([
+            EcuMemConnector.from_et(el, context)
+            for el in et_element.iterfind("ECU-MEM-CONNECTORS/ECU-MEM-CONNECTOR")
+        ])
+        additional_audiences = NamedItemList([
+            AdditionalAudience.from_et(el, context)
+            for el in et_element.iterfind("ADDITIONAL-AUDIENCES/ADDITIONAL-AUDIENCE")
+        ])
+
+        return Flash(
+            ecu_mems=ecu_mems,
+            ecu_mem_connectors=ecu_mem_connectors,
+            additional_audiences=additional_audiences,
+            **kwargs)
+
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
+        odxlinks = super()._build_odxlinks()
+
+        for ecu_mem in self.ecu_mems:
+            odxlinks.update(ecu_mem._build_odxlinks())
+
+        for ecu_mem_connector in self.ecu_mem_connectors:
+            odxlinks.update(ecu_mem_connector._build_odxlinks())
+
+        for additional_audiences in self.additional_audiences:
+            odxlinks.update(additional_audiences._build_odxlinks())
+
+        return odxlinks
+
+    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
+        super()._resolve_odxlinks(odxlinks)
+
+        for ecu_mem in self.ecu_mems:
+            ecu_mem._resolve_odxlinks(odxlinks)
+
+        for ecu_mem_connector in self.ecu_mem_connectors:
+            ecu_mem_connector._resolve_odxlinks(odxlinks)
+
+        for additional_audiences in self.additional_audiences:
+            additional_audiences._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 ecu_mem in self.ecu_mems:
+            ecu_mem._resolve_snrefs(context)
+
+        for ecu_mem_connector in self.ecu_mem_connectors:
+            ecu_mem_connector._resolve_snrefs(context)
+
+        for additional_audiences in self.additional_audiences:
+            additional_audiences._resolve_snrefs(context)

odxtools/flashclass.py

@@ -0,0 +1,32 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass
+from typing import Any
+from xml.etree import ElementTree
+
+from .element import IdentifiableElement
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkId
+from .snrefcontext import SnRefContext
+from .utils import dataclass_fields_asdict
+
+
+@dataclass(kw_only=True)
+class FlashClass(IdentifiableElement):
+    """
+    Corresponds to FLASH-CLASS.
+    """
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "FlashClass":
+        kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, context))
+
+        return FlashClass(**kwargs)
+
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
+        return {self.odx_id: self}
+
+    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
+        pass
+
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
+        pass

odxtools/flashdata.py

@@ -0,0 +1,70 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass
+from typing import Any
+from xml.etree import ElementTree
+
+from .dataformat import Dataformat
+from .element import IdentifiableElement
+from .encryptcompressmethod import EncryptCompressMethod
+from .exceptions import odxrequire
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkId
+from .snrefcontext import SnRefContext
+from .utils import dataclass_fields_asdict
+
+
+@dataclass(kw_only=True)
+class Flashdata(IdentifiableElement):
+    size_length: int | None = None
+    address_length: int | None = None
+    dataformat: Dataformat
+    encrypt_compress_method: EncryptCompressMethod | None = None
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "Flashdata":
+
+        kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, context))
+
+        size_length = None
+        if (size_length_str := et_element.findtext("SIZE-LENGTH")) is not None:
+            size_length = int(size_length_str)
+
+        address_length = None
+        if (address_length_str := et_element.findtext("ADDRESS-LENGTH")) is not None:
+            address_length = int(address_length_str)
+
+        dataformat = Dataformat.from_et(odxrequire(et_element.find("DATAFORMAT")), context)
+
+        encrypt_compress_method = None
+        if (encrypt_compress_method_elem := et_element.find("ENCRYPT-COMPRESS-METHOD")) is not None:
+            encrypt_compress_method = EncryptCompressMethod.from_et(encrypt_compress_method_elem,
+                                                                    context)
+
+        return Flashdata(
+            size_length=size_length,
+            address_length=address_length,
+            dataformat=dataformat,
+            encrypt_compress_method=encrypt_compress_method,
+            **kwargs)
+
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
+        odxlinks = {self.odx_id: self}
+
+        if self.dataformat is not None:
+            odxlinks.update(self.dataformat._build_odxlinks())
+        if self.encrypt_compress_method is not None:
+            odxlinks.update(self.encrypt_compress_method._build_odxlinks())
+
+        return odxlinks
+
+    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
+        if self.dataformat is not None:
+            self.dataformat._resolve_odxlinks(odxlinks)
+        if self.encrypt_compress_method is not None:
+            self.encrypt_compress_method._resolve_odxlinks(odxlinks)
+
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
+        if self.dataformat is not None:
+            self.dataformat._resolve_snrefs(context)
+        if self.encrypt_compress_method is not None:
+            self.encrypt_compress_method._resolve_snrefs(context)

odxtools/fwchecksum.py

@@ -0,0 +1,7 @@
+# SPDX-License-Identifier: MIT
+from .validityfor import ValidityFor
+
+# Note that the ODX specification specifies a separate tag for this,
+# but this tag is identical to VALIDITY-FOR, so let's use a type alias
+# to reduce the amount of copy-and-pasted code
+FwChecksum = ValidityFor

odxtools/fwsignature.py

@@ -0,0 +1,7 @@
+# SPDX-License-Identifier: MIT
+from .validityfor import ValidityFor
+
+# Note that the ODX specification specifies a separate tag for this,
+# but this tag is identical to VALIDITY-FOR, so let's use a type alias
+# to reduce the amount of copy-and-pasted code
+FwSignature = ValidityFor

odxtools/identdesc.py

@@ -0,0 +1,54 @@
+# 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 .snrefcontext import SnRefContext
+
+
+@dataclass(kw_only=True)
+class IdentDesc:
+    diag_comm_snref: str
+    ident_if_snref: str
+
+    # exactly one of the two attributes below must be defined
+    out_param_if_snref: str | None = None
+    out_param_if_snpathref: str | None = None
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "IdentDesc":
+        diag_comm_snref = odxrequire(
+            odxrequire(et_element.find("DIAG-COMM-SNREF")).attrib.get("SHORT-NAME"))
+        ident_if_snref = odxrequire(
+            odxrequire(et_element.find("IDENT-IF-SNREF")).attrib.get("SHORT-NAME"))
+        out_param_if_snref = None
+        if (out_param_if_snref_elem := et_element.find("OUT-PARAM-IF-SNREF")) is not None:
+            out_param_if_snref = odxrequire(out_param_if_snref_elem.attrib.get("SHORT-NAME"))
+
+        out_param_if_snpathref = None
+        if (out_param_if_snpathref_elem := et_element.find("OUT-PARAM-IF-SNPATHREF")) is not None:
+            out_param_if_snpathref = odxrequire(
+                out_param_if_snpathref_elem.attrib.get("SHORT-NAME-PATH"))
+
+        return IdentDesc(
+            diag_comm_snref=diag_comm_snref,
+            ident_if_snref=ident_if_snref,
+            out_param_if_snref=out_param_if_snref,
+            out_param_if_snpathref=out_param_if_snpathref,
+        )
+
+    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:
+        # TODO: resolve the short name references. for IdentDesc this
+        # is (probably) not possible ahead of time...
+        pass

odxtools/identvalue.py

@@ -0,0 +1,32 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass
+from xml.etree import ElementTree
+
+from .exceptions import odxraise
+from .identvaluetype import IdentValueType
+from .odxdoccontext import OdxDocContext
+
+
+@dataclass(kw_only=True)
+class IdentValue:
+    """
+    Corresponds to IDENT-VALUE.
+    """
+
+    value: str
+
+    # note that the spec says this attribute is named "TYPE", but in
+    # python, "type" is a build-in function...
+    value_type: IdentValueType
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "IdentValue":
+        value = et_element.text or ""
+
+        try:
+            value_type = IdentValueType(et_element.attrib["TYPE"])
+        except Exception as e:
+            odxraise(f"Cannot parse IDENT-VALUE-TYPE: {e}")
+            value_type = None
+
+        return IdentValue(value=value, value_type=value_type)

odxtools/identvaluetype.py

@@ -0,0 +1,14 @@
+# SPDX-License-Identifier: MIT
+from enum import Enum
+
+from .odxtypes import DataType
+
+
+class IdentValueType(Enum):
+    A_UINT32 = "A_UINT32"
+    A_BYTEFIELD = "A_BYTEFIELD"
+    A_ASCIISTRING = "A_ASCIISTRING"
+
+    @property
+    def data_type(self) -> DataType:
+        return DataType(self.value)

odxtools/internflashdata.py

@@ -0,0 +1,33 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass
+from typing import Any
+from xml.etree import ElementTree
+
+from .exceptions import odxrequire
+from .flashdata import Flashdata
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkId
+from .snrefcontext import SnRefContext
+from .utils import dataclass_fields_asdict
+
+
+@dataclass(kw_only=True)
+class InternFlashdata(Flashdata):
+    data: str
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "InternFlashdata":
+        kwargs = dataclass_fields_asdict(Flashdata.from_et(et_element, context))
+
+        data = odxrequire(et_element.findtext("DATA"))
+
+        return InternFlashdata(data=data, **kwargs)
+
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
+        return super()._build_odxlinks()
+
+    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
+        super()._resolve_odxlinks(odxlinks)
+
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
+        super()._resolve_snrefs(context)

odxtools/loadfile.py

@@ -23,7 +23,7 @@ def load_odx_d_file(odx_d_file_name: str | Path) -> Database:
 def load_file(file_name: str | Path) -> Database:
     if str(file_name).lower().endswith(".pdx"):
         return load_pdx_file(str(file_name))
-    elif str(file_name).lower().endswith(".odx-d"):
+    elif Path(file_name).suffix.lower().startswith(".odx"):
         return load_odx_d_file(str(file_name))
     else:
         raise RuntimeError(f"Could not guess the file format of file '{file_name}'!")