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

odxtools/database.py

@@ -19,6 +19,7 @@ from .diaglayers.ecuvariant import EcuVariant
 from .diaglayers.functionalgroup import FunctionalGroup
 from .diaglayers.protocol import Protocol
 from .exceptions import odxraise, odxrequire
+from .flash import Flash
 from .nameditemlist import NamedItemList
 from .odxdoccontext import OdxDocContext
 from .odxlink import DocType, OdxDocFragment, OdxLinkDatabase, OdxLinkId
@@ -39,6 +40,7 @@ class Database:
         self._diag_layer_containers = NamedItemList[DiagLayerContainer]()
         self._comparam_subsets = NamedItemList[ComparamSubset]()
         self._comparam_specs = NamedItemList[ComparamSpec]()
+        self._flashs = NamedItemList[Flash]()
         self._short_name = "odx_database"
 
     def add_pdx_file(self, pdx_file: Union[str, "PathLike[Any]", IO[bytes], ZipFile]) -> None:
@@ -57,7 +59,7 @@ class Database:
             p = Path(zip_member)
             if p.suffix.lower().startswith(".odx"):
                 root = ElementTree.parse(pdx_zip.open(zip_member)).getroot()
-                self._process_xml_tree(root)
+                self.add_xml_tree(root)
             elif p.name.lower() == "index.xml":
                 root = ElementTree.parse(pdx_zip.open(zip_member)).getroot()
                 db_short_name = odxrequire(root.findtext("SHORT-NAME"))
@@ -66,7 +68,7 @@ class Database:
                 self.add_auxiliary_file(zip_member, pdx_zip.open(zip_member))
 
     def add_odx_file(self, odx_file_name: Union[str, "PathLike[Any]"]) -> None:
-        self._process_xml_tree(ElementTree.parse(odx_file_name).getroot())
+        self.add_xml_tree(ElementTree.parse(odx_file_name).getroot())
 
     def add_auxiliary_file(self,
                            aux_file_name: Union[str, "PathLike[Any]"],
@@ -76,7 +78,7 @@ class Database:
 
         self.auxiliary_files[str(aux_file_name)] = aux_file_obj
 
-    def _process_xml_tree(self, root: ElementTree.Element) -> None:
+    def add_xml_tree(self, root: ElementTree.Element) -> None:
         # ODX spec version
         model_version = Version(root.attrib.get("MODEL-VERSION", "2.0"))
         if self.model_version is not None and self.model_version != model_version:
@@ -112,6 +114,9 @@ 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 == "FLASH":
+            context = OdxDocContext(model_version, (OdxDocFragment(category_sn, DocType.FLASH),))
+            self._flashs.append(Flash.from_et(category_et, context))
 
     def refresh(self) -> None:
         # Create wrapper objects
@@ -143,6 +148,9 @@ class Database:
         for dlc in self.diag_layer_containers:
             dlc._resolve_odxlinks(self._odxlinks)
 
+        for flash in self.flashs:
+            flash._resolve_odxlinks(self._odxlinks)
+
         # resolve short name references for containers which do not do
         # inheritance (we can call directly call _resolve_snrefs())
         context = SnRefContext()
@@ -155,6 +163,8 @@ class Database:
             spec._finalize_init(self, self._odxlinks)
         for dlc in self.diag_layer_containers:
             dlc._finalize_init(self, self._odxlinks)
+        for flash in self.flashs:
+            flash._finalize_init(self, self._odxlinks)
 
         for subset in self.comparam_subsets:
             subset._resolve_snrefs(context)
@@ -162,6 +172,8 @@ class Database:
             spec._resolve_snrefs(context)
         for dlc in self.diag_layer_containers:
             dlc._resolve_snrefs(context)
+        for flash in self.flashs:
+            flash._resolve_snrefs(context)
 
     def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         result: dict[OdxLinkId, Any] = {}
@@ -175,6 +187,9 @@ class Database:
         for dlc in self.diag_layer_containers:
             result.update(dlc._build_odxlinks())
 
+        for flash in self.flashs:
+            result.update(flash._build_odxlinks())
+
         return result
 
     @property
@@ -248,10 +263,15 @@ class Database:
     def comparam_specs(self) -> NamedItemList[ComparamSpec]:
         return self._comparam_specs
 
+    @property
+    def flashs(self) -> NamedItemList[Flash]:
+        return self._flashs
+
     def __repr__(self) -> str:
         return f"Database(model_version={self.model_version}, " \
             f"protocols={[x.short_name for x in self.protocols]}, " \
             f"ecus={[x.short_name for x in self.ecus]}, " \
             f"diag_layer_containers={repr(self.diag_layer_containers)}, " \
             f"comparam_subsets={repr(self.comparam_subsets)}, " \
-            f"comparam_specs={repr(self.comparam_specs)})"
+            f"comparam_specs={repr(self.comparam_specs)}, " \
+            f"flashs={repr(self.flashs)})"

odxtools/datablock.py

@@ -0,0 +1,153 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass, field
+from typing import Any
+from xml.etree import ElementTree
+
+from .addrdeffilter import AddrdefFilter
+from .audience import Audience
+from .element import IdentifiableElement
+from .exceptions import odxraise, odxrequire
+from .filter import Filter
+from .flashdata import Flashdata
+from .globals import xsi
+from .nameditemlist import NamedItemList
+from .negoffset import NegOffset
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkId, OdxLinkRef
+from .ownident import OwnIdent
+from .posoffset import PosOffset
+from .security import Security
+from .segment import Segment
+from .sizedeffilter import SizedefFilter
+from .snrefcontext import SnRefContext
+from .specialdatagroup import SpecialDataGroup
+from .targetaddroffset import TargetAddrOffset
+from .utils import dataclass_fields_asdict, read_hex_binary
+
+
+@dataclass(kw_only=True)
+class Datablock(IdentifiableElement):
+    logical_block_index: int | None = None
+    flashdata_ref: OdxLinkRef | None = None
+    filters: list[Filter] = field(default_factory=list)
+    segments: NamedItemList[Segment] = field(default_factory=NamedItemList)
+
+    # the specification does not define the content of
+    # TARGET-ADDR-OFFSET, i.e., if it is defined, it must be one of
+    # its specializations
+    target_addr_offset: TargetAddrOffset | None = None
+
+    own_idents: NamedItemList[OwnIdent] = field(default_factory=NamedItemList)
+    securities: list[Security] = field(default_factory=list)
+    sdgs: list[SpecialDataGroup] = field(default_factory=list)
+    audience: Audience | None = None
+
+    # note that the spec says this attribute is named "TYPE", but in
+    # python, "type" is a build-in function...
+    data_type: str
+
+    @property
+    def flashdata(self) -> Flashdata | None:
+        return self._flashdata
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "Datablock":
+
+        kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, context))
+
+        logical_block_index = read_hex_binary(et_element.find("LOGICAL-BLOCK-INDEX"))
+        flashdata_ref = OdxLinkRef.from_et(et_element.find("FLASHDATA-REF"), context)
+        filters: list[Filter] = []
+        for filter_elem in et_element.iterfind("FILTERS/FILTER"):
+            filter_type = filter_elem.attrib.get(f"{xsi}type")
+            if filter_type == "ADDRDEF-FILTER":
+                filters.append(AddrdefFilter.from_et(filter_elem, context))
+            elif filter_type == "SIZEDEF-FILTER":
+                filters.append(SizedefFilter.from_et(filter_elem, context))
+            else:
+                odxraise(f"Encountered filter of illegal type {filter_type}")
+                filters.append(Filter.from_et(filter_elem, context))
+        segments = NamedItemList([
+            Segment.from_et(segment_elem, context)
+            for segment_elem in et_element.iterfind("SEGMENTS/SEGMENT")
+        ])
+        target_addr_offset: TargetAddrOffset | None = None
+        if (tao_elem := et_element.find("TARGET-ADDR-OFFSET")) is not None:
+            tao_type = tao_elem.attrib.get(f"{xsi}type")
+            if tao_type == "POS-OFFSET":
+                target_addr_offset = PosOffset.from_et(tao_elem, context)
+            elif tao_type == "NEG-OFFSET":
+                target_addr_offset = NegOffset.from_et(tao_elem, context)
+            else:
+                odxraise(f"Unknown TARGET-ADDR-OFFSET type '{tao_type}'")
+
+        own_idents = NamedItemList([
+            OwnIdent.from_et(own_ident_elem, context)
+            for own_ident_elem in et_element.iterfind("OWN-IDENTS/OWN-IDENT")
+        ])
+        securities = [
+            Security.from_et(security_elem, context)
+            for security_elem in et_element.iterfind("SECURITYS/SECURITY")
+        ]
+        sdgs = [SpecialDataGroup.from_et(sdge, context) for sdge in et_element.iterfind("SDGS/SDG")]
+        audience = None
+        if (audience_elem := et_element.find("AUDIENCE")) is not None:
+            audience = Audience.from_et(audience_elem, context)
+        data_type = odxrequire(et_element.attrib.get("TYPE"))
+
+        return Datablock(
+            logical_block_index=logical_block_index,
+            flashdata_ref=flashdata_ref,
+            filters=filters,
+            segments=segments,
+            own_idents=own_idents,
+            securities=securities,
+            target_addr_offset=target_addr_offset,
+            sdgs=sdgs,
+            audience=audience,
+            data_type=data_type,
+            **kwargs)
+
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
+        odxlinks = {self.odx_id: self}
+
+        for odxfilter in self.filters:
+            odxlinks.update(odxfilter._build_odxlinks())
+        for segment in self.segments:
+            odxlinks.update(segment._build_odxlinks())
+        for own_indent in self.own_idents:
+            odxlinks.update(own_indent._build_odxlinks())
+        for sdg in self.sdgs:
+            odxlinks.update(sdg._build_odxlinks())
+        if self.audience is not None:
+            odxlinks.update(self.audience._build_odxlinks())
+
+        return odxlinks
+
+    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
+        self._flashdata = None
+        if self.flashdata_ref is not None:
+            self._flashdata = odxlinks.resolve(self.flashdata_ref, Flashdata)
+
+        for odxfilter in self.filters:
+            odxfilter._resolve_odxlinks(odxlinks)
+        for segment in self.segments:
+            segment._resolve_odxlinks(odxlinks)
+        for own_indent in self.own_idents:
+            own_indent._resolve_odxlinks(odxlinks)
+        for sdg in self.sdgs:
+            sdg._resolve_odxlinks(odxlinks)
+        if self.audience is not None:
+            self.audience._resolve_odxlinks(odxlinks)
+
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
+        for odxfilter in self.filters:
+            odxfilter._resolve_snrefs(context)
+        for segment in self.segments:
+            segment._resolve_snrefs(context)
+        for own_indent in self.own_idents:
+            own_indent._resolve_snrefs(context)
+        for sdg in self.sdgs:
+            sdg._resolve_snrefs(context)
+        if self.audience is not None:
+            self.audience._resolve_snrefs(context)

odxtools/datafile.py

@@ -0,0 +1,23 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass
+from xml.etree import ElementTree
+
+from .exceptions import odxrequire
+from .odxdoccontext import OdxDocContext
+from .odxtypes import odxstr_to_bool
+
+
+@dataclass(kw_only=True)
+class Datafile:
+    value: str
+    latebound_datafile: bool
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "Datafile":
+        value = et_element.text or ""
+        latebound_datafile = odxrequire(odxstr_to_bool(et_element.attrib.get("LATEBOUND-DATAFILE")))
+
+        return Datafile(
+            value=value,
+            latebound_datafile=latebound_datafile,
+        )

odxtools/dataformat.py

@@ -0,0 +1,39 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass
+from typing import Any, cast
+from xml.etree import ElementTree
+
+from .dataformatselection import DataformatSelection
+from .exceptions import odxraise, odxrequire
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkId
+from .snrefcontext import SnRefContext
+
+
+@dataclass(kw_only=True)
+class Dataformat:
+    selection: DataformatSelection
+    user_selection: str | None = None
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "Dataformat":
+        selection_str = odxrequire(et_element.attrib.get("SELECTION"))
+        try:
+            selection = DataformatSelection(selection_str)
+        except ValueError:
+            selection = cast(DataformatSelection, None)
+            odxraise(f"Encountered unknown data format selection '{selection_str}'")
+        user_selection = et_element.attrib.get("USER-SELECTION")
+
+        return Dataformat(selection=selection, user_selection=user_selection)
+
+    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/dataformatselection.py

@@ -0,0 +1,9 @@
+# SPDX-License-Identifier: MIT
+from enum import Enum
+
+
+class DataformatSelection(Enum):
+    INTEL_HEX = "INTEL-HEX"
+    MOTOROLA_S = "MOTOROLA-S"
+    BINARY = "BINARY"
+    USER_DEFINED = "USER-DEFINED"

odxtools/description.py

@@ -5,6 +5,7 @@ from xml.etree import ElementTree
 from .exceptions import odxrequire
 from .externaldoc import ExternalDoc
 from .odxdoccontext import OdxDocContext
+from .utils import strip_indent
 
 
 @dataclass(kw_only=True)
@@ -27,11 +28,7 @@ class Description:
                 break
             raw_string += ElementTree.tostring(e, encoding="unicode")
 
-        # remove white spaces at the beginning and at the end of all
-        # extracted lines
-        stripped_lines = [x.strip() for x in raw_string.split("\n")]
-
-        text = "\n".join(stripped_lines).strip()
+        text = strip_indent(raw_string)
 
         external_docs = \
             [

odxtools/diagdatadictionaryspec.py

@@ -46,9 +46,7 @@ class DiagDataDictionarySpec:
     @staticmethod
     def from_et(et_element: ElementTree.Element,
                 context: OdxDocContext) -> "DiagDataDictionarySpec":
-        admin_data = None
-        if (admin_data_elem := et_element.find("ADMIN-DATA")) is not None:
-            admin_data = AdminData.from_et(admin_data_elem, context)
+        admin_data = AdminData.from_et(et_element.find("ADMIN-DATA"), context)
 
         dtc_dops = NamedItemList([
             DtcDop.from_et(dtc_dop_elem, context)

odxtools/direction.py

@@ -0,0 +1,7 @@
+# SPDX-License-Identifier: MIT
+from enum import Enum
+
+
+class Direction(Enum):
+    UPLOAD = "UPLOAD"
+    DOWNLOAD = "DOWNLOAD"

odxtools/ecumem.py

@@ -0,0 +1,71 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass, field
+from typing import Any
+from xml.etree import ElementTree
+
+from .admindata import AdminData
+from .element import IdentifiableElement
+from .exceptions import odxrequire
+from .mem import Mem
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkId
+from .physmem import PhysMem
+from .snrefcontext import SnRefContext
+from .specialdatagroup import SpecialDataGroup
+from .utils import dataclass_fields_asdict
+
+
+@dataclass(kw_only=True)
+class EcuMem(IdentifiableElement):
+    admin_data: AdminData | None = None
+    mem: Mem
+    phys_mem: PhysMem | None = None
+    sdgs: list[SpecialDataGroup] = field(default_factory=list)
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "EcuMem":
+
+        kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, context))
+
+        admin_data = AdminData.from_et(et_element.find("ADMIN-DATA"), context)
+        mem = Mem.from_et(odxrequire(et_element.find("MEM")), context)
+        phys_mem = None
+        if (phys_mem_elem := et_element.find("PHYS-MEM")) is not None:
+            phys_mem = PhysMem.from_et(phys_mem_elem, context)
+        sdgs = [SpecialDataGroup.from_et(sdge, context) for sdge in et_element.iterfind("SDGS/SDG")]
+
+        return EcuMem(admin_data=admin_data, mem=mem, phys_mem=phys_mem, 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())
+
+        odxlinks.update(self.mem._build_odxlinks())
+        if self.phys_mem is not None:
+            odxlinks.update(self.phys_mem._build_odxlinks())
+        for sdg in self.sdgs:
+            odxlinks.update(sdg._build_odxlinks())
+
+        return odxlinks
+
+    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
+        if self.admin_data is not None:
+            self.admin_data._resolve_odxlinks(odxlinks)
+
+        self.mem._resolve_odxlinks(odxlinks)
+        if self.phys_mem is not None:
+            self.phys_mem._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)
+
+        self.mem._resolve_snrefs(context)
+        if self.phys_mem is not None:
+            self.phys_mem._resolve_snrefs(context)
+        for sdg in self.sdgs:
+            sdg._resolve_snrefs(context)

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