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

odxtools/mem.py

@@ -0,0 +1,80 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass
+from typing import Any
+from xml.etree import ElementTree
+
+from .datablock import Datablock
+from .exceptions import odxraise
+from .externflashdata import ExternFlashdata
+from .flashdata import Flashdata
+from .globals import xsi
+from .internflashdata import InternFlashdata
+from .nameditemlist import NamedItemList
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkId
+from .session import Session
+from .snrefcontext import SnRefContext
+
+
+@dataclass(kw_only=True)
+class Mem:
+    sessions: NamedItemList[Session]
+    datablocks: NamedItemList[Datablock]
+    flashdatas: NamedItemList[Flashdata]
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "Mem":
+        sessions = NamedItemList([
+            Session.from_et(sess_elem, context)
+            for sess_elem in et_element.iterfind("SESSIONS/SESSION")
+        ])
+
+        datablocks = NamedItemList([
+            Datablock.from_et(db_elem, context)
+            for db_elem in et_element.iterfind("DATABLOCKS/DATABLOCK")
+        ])
+
+        flashdatas: NamedItemList[Flashdata] = NamedItemList()
+        for flashdata_elem in et_element.iterfind("FLASHDATAS/FLASHDATA"):
+            flashdata_type = flashdata_elem.attrib.get(f"{xsi}type")
+            if flashdata_type == "INTERN-FLASHDATA":
+                flashdatas.append(InternFlashdata.from_et(flashdata_elem, context))
+            elif flashdata_type == "EXTERN-FLASHDATA":
+                flashdatas.append(ExternFlashdata.from_et(flashdata_elem, context))
+            else:
+                odxraise(f"Encountered unknown flashdata type {flashdata_type}")
+                flashdatas.append(Flashdata.from_et(flashdata_elem, context))
+
+        return Mem(
+            sessions=sessions,
+            datablocks=datablocks,
+            flashdatas=flashdatas,
+        )
+
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
+        odxlinks = {}
+
+        for session in self.sessions:
+            odxlinks.update(session._build_odxlinks())
+        for datablock in self.datablocks:
+            odxlinks.update(datablock._build_odxlinks())
+        for flashdata in self.flashdatas:
+            odxlinks.update(flashdata._build_odxlinks())
+
+        return odxlinks
+
+    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
+        for session in self.sessions:
+            session._resolve_odxlinks(odxlinks)
+        for datablock in self.datablocks:
+            datablock._resolve_odxlinks(odxlinks)
+        for flashdata in self.flashdatas:
+            flashdata._resolve_odxlinks(odxlinks)
+
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
+        for session in self.sessions:
+            session._resolve_snrefs(context)
+        for datablock in self.datablocks:
+            datablock._resolve_snrefs(context)
+        for flashdata in self.flashdatas:
+            flashdata._resolve_snrefs(context)

odxtools/modification.py

@@ -7,6 +7,7 @@ from .exceptions import odxrequire
 from .odxdoccontext import OdxDocContext
 from .odxlink import OdxLinkDatabase, OdxLinkId
 from .snrefcontext import SnRefContext
+from .utils import strip_indent
 
 
 @dataclass(kw_only=True)
@@ -16,8 +17,8 @@ class Modification:
 
     @staticmethod
     def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "Modification":
-        change = odxrequire(et_element.findtext("CHANGE"))
-        reason = et_element.findtext("REASON")
+        change = odxrequire(strip_indent(et_element.findtext("CHANGE")))
+        reason = strip_indent(et_element.findtext("REASON"))
 
         return Modification(change=change, reason=reason)
 

odxtools/negoffset.py

@@ -0,0 +1,21 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass
+from xml.etree import ElementTree
+
+from .exceptions import odxrequire
+from .odxdoccontext import OdxDocContext
+from .targetaddroffset import TargetAddrOffset
+from .utils import dataclass_fields_asdict, read_hex_binary
+
+
+@dataclass(kw_only=True)
+class NegOffset(TargetAddrOffset):
+    negative_offset: int
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "NegOffset":
+        kwargs = dataclass_fields_asdict(TargetAddrOffset.from_et(et_element, context))
+
+        negative_offset = odxrequire(read_hex_binary(et_element.find("NEGATIVE-OFFSET")))
+
+        return NegOffset(negative_offset=negative_offset, **kwargs)

odxtools/ownident.py

@@ -0,0 +1,38 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass
+from typing import Any
+from xml.etree import ElementTree
+
+from .element import IdentifiableElement
+from .exceptions import odxrequire
+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 OwnIdent(IdentifiableElement):
+    """
+    Corresponds to OWN-IDENT.
+    """
+
+    ident_value: IdentValue
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "OwnIdent":
+        kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, context))
+
+        ident_value = IdentValue.from_et(odxrequire(et_element.find("IDENT-VALUE")), context)
+
+        return OwnIdent(ident_value=ident_value, **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/physicaltype.py

@@ -2,7 +2,7 @@
 from dataclasses import dataclass
 from xml.etree import ElementTree
 
-from .exceptions import odxraise
+from .exceptions import odxraise, odxrequire
 from .odxdoccontext import OdxDocContext
 from .odxtypes import DataType
 from .radix import Radix
@@ -31,27 +31,29 @@ class PhysicalType:
     PhysicalType(DataType.A_FLOAT64, precision=2)
     """
 
+    #: Number of digits after the decimal point to display to the user
+    #: The precision is only applicable if the base data type is
+    #: A_FLOAT32 or A_FLOAT64.
     precision: int | None = None
-    """Number of digits after the decimal point to display to the user
-    The precision is only applicable if the base data type is A_FLOAT32 or A_FLOAT64.
-    """
 
     base_data_type: DataType
 
+    #: The display radix defines how integers are displayed to the
+    #: user. The display radix is only applicable if the base data type
+    #: is A_UINT32.
     display_radix: Radix | None = None
-    """The display radix defines how integers are displayed to the user.
-    The display radix is only applicable if the base data type is A_UINT32.
-    """
 
     @staticmethod
     def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "PhysicalType":
         precision_str = et_element.findtext("PRECISION")
         precision = int(precision_str) if precision_str is not None else None
 
-        base_data_type_str = et_element.get("BASE-DATA-TYPE")
-        if base_data_type_str not in DataType.__members__:
+        base_data_type_str = odxrequire(et_element.attrib.get("BASE-DATA-TYPE"))
+        try:
+            base_data_type = DataType(base_data_type_str)
+        except ValueError:
             odxraise(f"Encountered unknown base data type '{base_data_type_str}'")
-        base_data_type = DataType(base_data_type_str)
+            base_data_type = None
 
         display_radix_str = et_element.get("DISPLAY-RADIX")
         if display_radix_str is not None:

odxtools/physmem.py

@@ -0,0 +1,52 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass
+from typing import Any
+from xml.etree import ElementTree
+
+from .addrdefphyssegment import AddrdefPhysSegment
+from .element import IdentifiableElement
+from .globals import xsi
+from .nameditemlist import NamedItemList
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkId
+from .physsegment import PhysSegment
+from .sizedefphyssegment import SizedefPhysSegment
+from .snrefcontext import SnRefContext
+from .utils import dataclass_fields_asdict
+
+
+@dataclass(kw_only=True)
+class PhysMem(IdentifiableElement):
+    phys_segments: NamedItemList[PhysSegment]
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "PhysMem":
+        kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, context))
+
+        phys_segments: NamedItemList[PhysSegment] = NamedItemList()
+        for phys_segment_elem in et_element.iterfind("PHYS-SEGMENTS/PHYS-SEGMENT"):
+            phys_segment_type = phys_segment_elem.attrib.get(f"{xsi}type")
+            if phys_segment_type == "ADDRDEF-PHYS-SEGMENT":
+                phys_segments.append(AddrdefPhysSegment.from_et(phys_segment_elem, context))
+            elif phys_segment_type == "SIZEDEF-PHYS-SEGMENT":
+                phys_segments.append(SizedefPhysSegment.from_et(phys_segment_elem, context))
+            else:
+                phys_segments.append(PhysSegment.from_et(phys_segment_elem, context))
+
+        return PhysMem(phys_segments=phys_segments, **kwargs)
+
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
+        odxlinks = {self.odx_id: self}
+
+        for phys_segment in self.phys_segments:
+            odxlinks.update(phys_segment._build_odxlinks())
+
+        return odxlinks
+
+    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
+        for phys_segment in self.phys_segments:
+            phys_segment._resolve_odxlinks(odxlinks)
+
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
+        for phys_segment in self.phys_segments:
+            phys_segment._resolve_snrefs(context)

odxtools/physsegment.py

@@ -0,0 +1,42 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass
+from typing import Any
+from xml.etree import ElementTree
+
+from .element import IdentifiableElement
+from .exceptions import odxrequire
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkId
+from .snrefcontext import SnRefContext
+from .utils import dataclass_fields_asdict, read_hex_binary
+
+
+@dataclass(kw_only=True)
+class PhysSegment(IdentifiableElement):
+    fillbyte: int | None = None
+    block_size: int | None = None
+    start_address: int
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "PhysSegment":
+        kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, context))
+
+        fillbyte = read_hex_binary(et_element.find("FILLBYTE"))
+        block_size = 0
+        if (bs_elem := et_element.find("BLOCK-SIZE")) is not None:
+            block_size = int(odxrequire(bs_elem.text) or "0")
+        start_address = odxrequire(read_hex_binary(et_element.find("START-ADDRESS")))
+
+        return PhysSegment(
+            fillbyte=fillbyte, block_size=block_size, start_address=start_address, **kwargs)
+
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
+        odxlinks = {self.odx_id: self}
+
+        return odxlinks
+
+    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
+        pass
+
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
+        pass

odxtools/posoffset.py

@@ -0,0 +1,21 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass
+from xml.etree import ElementTree
+
+from .exceptions import odxrequire
+from .odxdoccontext import OdxDocContext
+from .targetaddroffset import TargetAddrOffset
+from .utils import dataclass_fields_asdict, read_hex_binary
+
+
+@dataclass(kw_only=True)
+class PosOffset(TargetAddrOffset):
+    positive_offset: int
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "PosOffset":
+        kwargs = dataclass_fields_asdict(TargetAddrOffset.from_et(et_element, context))
+
+        positive_offset = odxrequire(read_hex_binary(et_element.find("POSITIVE-OFFSET")))
+
+        return PosOffset(positive_offset=positive_offset, **kwargs)

odxtools/security.py

@@ -0,0 +1,42 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass
+from xml.etree import ElementTree
+
+from .fwchecksum import FwChecksum
+from .fwsignature import FwSignature
+from .odxdoccontext import OdxDocContext
+from .securitymethod import SecurityMethod
+from .validityfor import ValidityFor
+
+
+@dataclass(kw_only=True)
+class Security:
+    security_method: SecurityMethod | None = None
+    fw_signature: FwSignature | None = None
+    fw_checksum: FwChecksum | None = None
+    validity_for: ValidityFor | None = None
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "Security":
+        security_method = None
+        if (sm_elem := et_element.find("SECURITY-METHOD")) is not None:
+            security_method = SecurityMethod.from_et(sm_elem, context)
+
+        fw_signature = None
+        if (fws_elem := et_element.find("FW-SIGNATURE")) is not None:
+            fw_signature = FwSignature.from_et(fws_elem, context)
+
+        fw_checksum = None
+        if (fwcs_elem := et_element.find("FW-CHECKSUM")) is not None:
+            fw_checksum = FwChecksum.from_et(fwcs_elem, context)
+
+        validity_for = None
+        if (val_elem := et_element.find("VALIDITY-FOR")) is not None:
+            validity_for = ValidityFor.from_et(val_elem, context)
+
+        return Security(
+            security_method=security_method,
+            fw_signature=fw_signature,
+            fw_checksum=fw_checksum,
+            validity_for=validity_for,
+        )

odxtools/securitymethod.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
+SecurityMethod = ValidityFor

odxtools/segment.py

@@ -0,0 +1,63 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass
+from typing import Any
+from xml.etree import ElementTree
+
+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, read_hex_binary
+
+
+@dataclass(kw_only=True)
+class Segment(IdentifiableElement):
+    source_start_address: int
+    compressed_size: int | None = None
+
+    # exactly one of the two next fields must be not None
+    uncompressed_size: int | None = None
+    source_end_address: int | None = None
+
+    encrypt_compress_method: EncryptCompressMethod | None = None
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "Segment":
+        kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, context))
+
+        source_start_address = odxrequire(read_hex_binary(et_element.find("SOURCE-START-ADDRESS")))
+        compressed_size = None
+        if (cs_elem := et_element.find("COMPRESSED-SIZE")) is not None:
+            compressed_size = int(odxrequire(cs_elem.text) or "0")
+
+        # exactly one of the two next fields must be not None
+        uncompressed_size = None
+        if (ucs_elem := et_element.find("UNCOMPRESSED-SIZE")) is not None:
+            uncompressed_size = int(odxrequire(ucs_elem.text) or "0")
+        source_end_address = read_hex_binary(et_element.find("SOURCE-END-ADDRESS"))
+
+        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 Segment(
+            source_start_address=source_start_address,
+            compressed_size=compressed_size,
+            uncompressed_size=uncompressed_size,
+            source_end_address=source_end_address,
+            encrypt_compress_method=encrypt_compress_method,
+            **kwargs)
+
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
+        odxlinks = {self.odx_id: self}
+
+        return odxlinks
+
+    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
+        pass
+
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
+        pass

odxtools/session.py

@@ -0,0 +1,88 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass, field
+from typing import Any
+from xml.etree import ElementTree
+
+from .checksum import Checksum
+from .datablock import Datablock
+from .element import IdentifiableElement
+from .expectedident import ExpectedIdent
+from .nameditemlist import NamedItemList
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkId, OdxLinkRef
+from .security import Security
+from .snrefcontext import SnRefContext
+from .specialdatagroup import SpecialDataGroup
+from .utils import dataclass_fields_asdict
+
+
+@dataclass(kw_only=True)
+class Session(IdentifiableElement):
+    expected_idents: NamedItemList[ExpectedIdent] = field(default_factory=NamedItemList)
+    checksums: NamedItemList[Checksum] = field(default_factory=NamedItemList)
+    securities: list[Security] = field(default_factory=list)
+    datablock_refs: list[OdxLinkRef] = field(default_factory=list)
+    sdgs: list[SpecialDataGroup] = field(default_factory=list)
+
+    @property
+    def datablocks(self) -> NamedItemList[Datablock]:
+        return self._datablocks
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "Session":
+
+        kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, context))
+
+        expected_idents = NamedItemList([
+            ExpectedIdent.from_et(el, context)
+            for el in et_element.iterfind("EXPECTED-IDENTS/EXPECTED-IDENT")
+        ])
+        checksums = NamedItemList(
+            [Checksum.from_et(el, context) for el in et_element.iterfind("CHECKSUMS/CHECKSUM")])
+        securities = [
+            Security.from_et(el, context) for el in et_element.iterfind("SECURITYS/SECURITY")
+        ]
+        datablock_refs = [
+            OdxLinkRef.from_et(el, context)
+            for el in et_element.iterfind("DATABLOCK-REFS/DATABLOCK-REF")
+        ]
+        sdgs = [SpecialDataGroup.from_et(sdge, context) for sdge in et_element.iterfind("SDGS/SDG")]
+
+        return Session(
+            expected_idents=expected_idents,
+            checksums=checksums,
+            securities=securities,
+            datablock_refs=datablock_refs,
+            sdgs=sdgs,
+            **kwargs)
+
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
+        odxlinks = {self.odx_id: self}
+
+        for ei in self.expected_idents:
+            odxlinks.update(ei._build_odxlinks())
+        for cs in self.checksums:
+            odxlinks.update(cs._build_odxlinks())
+        for sdg in self.sdgs:
+            odxlinks.update(sdg._build_odxlinks())
+
+        return odxlinks
+
+    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
+        self._datablocks = NamedItemList(
+            [odxlinks.resolve(ref, Datablock) for ref in self.datablock_refs])
+
+        for ei in self.expected_idents:
+            ei._resolve_odxlinks(odxlinks)
+        for cs in self.checksums:
+            cs._resolve_odxlinks(odxlinks)
+        for sdg in self.sdgs:
+            sdg._resolve_odxlinks(odxlinks)
+
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
+        for ei in self.expected_idents:
+            ei._resolve_snrefs(context)
+        for cs in self.checksums:
+            cs._resolve_snrefs(context)
+        for sdg in self.sdgs:
+            sdg._resolve_snrefs(context)

odxtools/sessiondesc.py

@@ -0,0 +1,101 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass, field
+from typing import Any, cast
+from xml.etree import ElementTree
+
+from .audience import Audience
+from .direction import Direction
+from .element import NamedElement
+from .exceptions import odxraise, odxrequire
+from .flashclass import FlashClass
+from .nameditemlist import NamedItemList
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkId, OdxLinkRef
+from .ownident import OwnIdent
+from .snrefcontext import SnRefContext
+from .specialdatagroup import SpecialDataGroup
+from .utils import dataclass_fields_asdict
+
+
+@dataclass(kw_only=True)
+class SessionDesc(NamedElement):
+    partnumber: str | None = None
+    priority: int | None = None
+    session_snref: str
+    diag_comm_snref: str | None = None
+    flash_class_refs: list[OdxLinkRef] = field(default_factory=list)
+    sdgs: list[SpecialDataGroup] = field(default_factory=list)
+    audience: Audience | None = None
+    own_ident: OwnIdent | None = None
+    oid: str | None = None
+    direction: Direction
+
+    @property
+    def flash_classes(self) -> NamedItemList[FlashClass]:
+        return self._flash_classes
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "SessionDesc":
+
+        kwargs = dataclass_fields_asdict(NamedElement.from_et(et_element, context))
+
+        partnumber = et_element.findtext("PARTNUMBER")
+        priority = None
+        if (priority_str := et_element.findtext("PRIORITY")) is not None:
+            try:
+                priority = int(priority_str)
+            except Exception as e:
+                odxraise(f"Cannot parse PRIORITY: {e}")
+        session_snref = None
+        if (session_snref_elem := odxrequire(et_element.find("SESSION-SNREF"))) is not None:
+            session_snref = odxrequire(session_snref_elem.attrib.get("SHORT-NAME"))
+        diag_comm_snref = None
+        if (diag_comm_snref_elem := et_element.find("DIAG-COMM-SNREF")) is not None:
+            diag_comm_snref = odxrequire(diag_comm_snref_elem.attrib.get("SHORT-NAME"))
+        flash_class_refs = [
+            OdxLinkRef.from_et(el, context)
+            for el in et_element.iterfind("FLASH-CLASS-REFS/FLASH-CLASS-REF")
+        ]
+        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)
+        own_ident = None
+        if (own_ident_elem := et_element.find("OWN-IDENT")) is not None:
+            own_ident = OwnIdent.from_et(own_ident_elem, context)
+        direction_str = odxrequire(et_element.attrib.get("DIRECTION"))
+        try:
+            direction = Direction(direction_str)
+        except ValueError:
+            odxraise(f"Encountered unknown DIRECTION '{direction_str}'")
+            direction = cast(Direction, None)
+        oid = et_element.attrib.get("OID")
+
+        return SessionDesc(
+            partnumber=partnumber,
+            priority=priority,
+            session_snref=session_snref,
+            diag_comm_snref=diag_comm_snref,
+            flash_class_refs=flash_class_refs,
+            sdgs=sdgs,
+            audience=audience,
+            own_ident=own_ident,
+            direction=direction,
+            oid=oid,
+            **kwargs)
+
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
+        odxlinks: dict[OdxLinkId, Any] = {}
+
+        if self.own_ident is not None:
+            odxlinks.update(self.own_ident._build_odxlinks())
+
+        return odxlinks
+
+    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
+        self._flash_classes = NamedItemList(
+            [odxlinks.resolve(ref, FlashClass) for ref in self.flash_class_refs])
+
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
+        # TODO: resolve session_snref and diag_comm_snref
+        pass

odxtools/sessionsubelemtype.py

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

odxtools/sizedeffilter.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 .filter import Filter
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkId
+from .snrefcontext import SnRefContext
+from .utils import dataclass_fields_asdict
+
+
+@dataclass(kw_only=True)
+class SizedefFilter(Filter):
+    filter_size: int
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "SizedefFilter":
+        kwargs = dataclass_fields_asdict(Filter.from_et(et_element, context))
+
+        filter_size = int(odxrequire(et_element.findtext("FILTER-SIZE")) or "0")
+
+        return SizedefFilter(filter_size=filter_size, **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)