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

odxtools/library.py

@@ -5,12 +5,13 @@ from xml.etree import ElementTree
 
 from .element import IdentifiableElement
 from .exceptions import odxraise, odxrequire
-from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkId
 from .snrefcontext import SnRefContext
 from .utils import dataclass_fields_asdict
 
 
-@dataclass
+@dataclass(kw_only=True)
 class Library(IdentifiableElement):
     """
     A library defines a shared library used for single ECU jobs etc.
@@ -19,19 +20,19 @@ class Library(IdentifiableElement):
     """
 
     code_file: str
-    encryption: str | None
+    encryption: str | None = None
     syntax: str
     revision: str
-    entrypoint: str | None
+    entrypoint: str | None = None
 
     @property
     def code(self) -> bytes:
         return self._code
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element, doc_frags: list[OdxDocFragment]) -> "Library":
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "Library":
 
-        kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, doc_frags))
+        kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, context))
 
         code_file = odxrequire(et_element.findtext("CODE-FILE"))
         encryption = et_element.findtext("ENCRYPTION")

odxtools/linkeddtcdop.py

@@ -1,21 +1,22 @@
 # SPDX-License-Identifier: MIT
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from typing import TYPE_CHECKING, Any
 from xml.etree import ElementTree
 
 from .diagnostictroublecode import DiagnosticTroubleCode
 from .exceptions import odxrequire
 from .nameditemlist import NamedItemList
-from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef, resolve_snref
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkId, OdxLinkRef, resolve_snref
 from .snrefcontext import SnRefContext
 
 if TYPE_CHECKING:
     from .dtcdop import DtcDop
 
 
-@dataclass
+@dataclass(kw_only=True)
 class LinkedDtcDop:
-    not_inherited_dtc_snrefs: list[str]
+    not_inherited_dtc_snrefs: list[str] = field(default_factory=list)
     dtc_dop_ref: OdxLinkRef
 
     @property
@@ -31,14 +32,14 @@ class LinkedDtcDop:
         return self._dtc_dop.short_name
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element, doc_frags: list[OdxDocFragment]) -> "LinkedDtcDop":
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "LinkedDtcDop":
         not_inherited_dtc_snrefs = [
             odxrequire(el.get("SHORT-NAME"))
             for el in et_element.iterfind("NOT-INHERITED-DTC-SNREFS/"
                                           "NOT-INHERITED-DTC-SNREF")
         ]
 
-        dtc_dop_ref = odxrequire(OdxLinkRef.from_et(et_element.find("DTC-DOP-REF"), doc_frags))
+        dtc_dop_ref = odxrequire(OdxLinkRef.from_et(et_element.find("DTC-DOP-REF"), context))
 
         return LinkedDtcDop(
             not_inherited_dtc_snrefs=not_inherited_dtc_snrefs, dtc_dop_ref=dtc_dop_ref)

odxtools/matchingbasevariantparameter.py

@@ -3,12 +3,12 @@ from dataclasses import dataclass
 from xml.etree import ElementTree
 
 from .matchingparameter import MatchingParameter
-from .odxlink import OdxDocFragment
+from .odxdoccontext import OdxDocContext
 from .odxtypes import odxstr_to_bool
 from .utils import dataclass_fields_asdict
 
 
-@dataclass
+@dataclass(kw_only=True)
 class MatchingBaseVariantParameter(MatchingParameter):
     """A description of a parameter used for base variant matching.
 
@@ -17,7 +17,7 @@ class MatchingBaseVariantParameter(MatchingParameter):
     additional subtag `USE-PHYSICAL-ADDRESSING`.
     """
 
-    use_physical_addressing_raw: bool | None
+    use_physical_addressing_raw: bool | None = None
 
     @property
     def use_physical_addressing(self) -> bool:
@@ -25,9 +25,9 @@ class MatchingBaseVariantParameter(MatchingParameter):
 
     @staticmethod
     def from_et(et_element: ElementTree.Element,
-                doc_frags: list[OdxDocFragment]) -> "MatchingBaseVariantParameter":
+                context: OdxDocContext) -> "MatchingBaseVariantParameter":
 
-        kwargs = dataclass_fields_asdict(MatchingParameter.from_et(et_element, doc_frags))
+        kwargs = dataclass_fields_asdict(MatchingParameter.from_et(et_element, context))
 
         use_physical_addressing_raw = odxstr_to_bool(et_element.findtext("USE-PHYSICAL-ADDRESSING"))
 

odxtools/matchingparameter.py

@@ -7,12 +7,13 @@ from .diaglayers.diaglayer import DiagLayer
 from .diagnostictroublecode import DiagnosticTroubleCode
 from .diagservice import DiagService
 from .exceptions import odxraise, odxrequire
-from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, resolve_snref
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkId, resolve_snref
 from .odxtypes import BytesTypes, ParameterValue, ParameterValueDict
 from .snrefcontext import SnRefContext
 
 
-@dataclass
+@dataclass(kw_only=True)
 class MatchingParameter:
     """According to ISO 22901, a MatchingParameter contains a string
     value identifying the active ECU or base variant. Moreover, it
@@ -34,12 +35,11 @@ class MatchingParameter:
     # or negative response. What it probably actually wants to say is
     # that any response that can possibly be received shall exhibit
     # the referenced parameter.
-    out_param_if_snref: str | None
-    out_param_if_snpathref: str | None
+    out_param_if_snref: str | None = None
+    out_param_if_snpathref: str | None = None
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element,
-                doc_frags: list[OdxDocFragment]) -> "MatchingParameter":
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "MatchingParameter":
 
         expected_value = odxrequire(et_element.findtext("EXPECTED-VALUE"))
         diag_comm_snref = odxrequire(

odxtools/message.py

@@ -10,7 +10,7 @@ if TYPE_CHECKING:
     from .response import Response
 
 
-@dataclass
+@dataclass(kw_only=True)
 class Message:
     """A diagnostic message with its interpretation.
 

odxtools/minmaxlengthtype.py

@@ -10,15 +10,15 @@ from .diagcodedtype import DctType, DiagCodedType
 from .encodestate import EncodeState
 from .encoding import get_string_encoding
 from .exceptions import DecodeError, EncodeError, odxassert, odxraise, odxrequire
-from .odxlink import OdxDocFragment
+from .odxdoccontext import OdxDocContext
 from .odxtypes import AtomicOdxType, BytesTypes, DataType
 from .termination import Termination
 from .utils import dataclass_fields_asdict
 
 
-@dataclass
+@dataclass(kw_only=True)
 class MinMaxLengthType(DiagCodedType):
-    max_length: int | None
+    max_length: int | None = None
     min_length: int
     termination: Termination
 
@@ -28,9 +28,8 @@ class MinMaxLengthType(DiagCodedType):
 
     @staticmethod
     @override
-    def from_et(et_element: ElementTree.Element,
-                doc_frags: list[OdxDocFragment]) -> "MinMaxLengthType":
-        kwargs = dataclass_fields_asdict(DiagCodedType.from_et(et_element, doc_frags))
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "MinMaxLengthType":
+        kwargs = dataclass_fields_asdict(DiagCodedType.from_et(et_element, context))
 
         max_length = None
         if et_element.find("MAX-LENGTH") is not None:
@@ -77,7 +76,7 @@ class MinMaxLengthType(DiagCodedType):
     @override
     def encode_into_pdu(self, internal_value: AtomicOdxType, encode_state: EncodeState) -> None:
 
-        if not isinstance(internal_value, str | BytesTypes):
+        if not isinstance(internal_value, (str, BytesTypes)):
             odxraise("MinMaxLengthType is currently only implemented for strings and byte arrays",
                      EncodeError)
 

odxtools/modification.py

@@ -4,17 +4,18 @@ from typing import Any
 from xml.etree import ElementTree
 
 from .exceptions import odxrequire
-from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkId
 from .snrefcontext import SnRefContext
 
 
-@dataclass
+@dataclass(kw_only=True)
 class Modification:
     change: str
-    reason: str | None
+    reason: str | None = None
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element, doc_frags: list[OdxDocFragment]) -> "Modification":
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "Modification":
         change = odxrequire(et_element.findtext("CHANGE"))
         reason = et_element.findtext("REASON")
 

odxtools/multiplexer.py

@@ -1,5 +1,5 @@
 # SPDX-License-Identifier: MIT
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from typing import Any, cast
 from xml.etree import ElementTree
 
@@ -13,13 +13,14 @@ from .multiplexercase import MultiplexerCase
 from .multiplexerdefaultcase import MultiplexerDefaultCase
 from .multiplexerswitchkey import MultiplexerSwitchKey
 from .nameditemlist import NamedItemList
-from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkId
 from .odxtypes import AtomicOdxType, ParameterValue, odxstr_to_bool
 from .snrefcontext import SnRefContext
 from .utils import dataclass_fields_asdict
 
 
-@dataclass
+@dataclass(kw_only=True)
 class Multiplexer(ComplexDop):
     """This class represents a Multiplexer (MUX)
 
@@ -30,9 +31,9 @@ class Multiplexer(ComplexDop):
 
     byte_position: int
     switch_key: MultiplexerSwitchKey
-    default_case: MultiplexerDefaultCase | None
-    cases: NamedItemList[MultiplexerCase]
-    is_visible_raw: bool | None
+    default_case: MultiplexerDefaultCase | None = None
+    cases: NamedItemList[MultiplexerCase] = field(default_factory=NamedItemList)
+    is_visible_raw: bool | None = None
 
     @property
     def is_visible(self) -> bool:
@@ -40,20 +41,20 @@ class Multiplexer(ComplexDop):
 
     @staticmethod
     @override
-    def from_et(et_element: ElementTree.Element, doc_frags: list[OdxDocFragment]) -> "Multiplexer":
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "Multiplexer":
         """Reads a Multiplexer from Diag Layer."""
-        kwargs = dataclass_fields_asdict(ComplexDop.from_et(et_element, doc_frags))
+        kwargs = dataclass_fields_asdict(ComplexDop.from_et(et_element, context))
 
         byte_position = int(et_element.findtext("BYTE-POSITION", "0"))
         switch_key = MultiplexerSwitchKey.from_et(
-            odxrequire(et_element.find("SWITCH-KEY")), doc_frags)
+            odxrequire(et_element.find("SWITCH-KEY")), context)
 
         default_case = None
         if (dc_elem := et_element.find("DEFAULT-CASE")) is not None:
-            default_case = MultiplexerDefaultCase.from_et(dc_elem, doc_frags)
+            default_case = MultiplexerDefaultCase.from_et(dc_elem, context)
 
         cases = NamedItemList(
-            [MultiplexerCase.from_et(el, doc_frags) for el in et_element.iterfind("CASES/CASE")])
+            [MultiplexerCase.from_et(el, context) for el in et_element.iterfind("CASES/CASE")])
 
         is_visible_raw = odxstr_to_bool(et_element.get("IS-VISIBLE"))
 
@@ -118,7 +119,7 @@ class Multiplexer(ComplexDop):
         orig_origin = encode_state.origin_byte_position
         encode_state.origin_byte_position = encode_state.cursor_byte_position
 
-        if isinstance(physical_value, list | tuple) and len(physical_value) == 2:
+        if isinstance(physical_value, (list, tuple)) and len(physical_value) == 2:
             case_spec, case_value = physical_value
         elif isinstance(physical_value, dict) and len(physical_value) == 1:
             case_spec, case_value = next(iter(physical_value.items()))
@@ -235,3 +236,38 @@ class Multiplexer(ComplexDop):
         decode_state.origin_byte_position = orig_origin
 
         return result
+
+    @override
+    def get_static_bit_length(self) -> int | None:
+        """
+        Returns the static bit length of the multiplexer structure, if determinable.
+
+        If all cases (including the default, if present) have the same static bit length,
+        the codec length is considered static and is returned.
+        Otherwise, returns None to indicate that the size is dynamic.
+        """
+        reference_case = self.default_case if self.default_case else self.cases[0]
+
+        case_bit_length: int | None
+        if reference_case.structure is None:
+            case_bit_length = 0
+        else:
+            case_bit_length = reference_case.structure.get_static_bit_length()
+        if case_bit_length is None:
+            return None
+        case_size: int | None
+        for mux_case in self.cases:
+            if mux_case.structure is None:
+                case_size = 0
+            else:
+                case_size = mux_case.structure.get_static_bit_length()
+            if case_size != case_bit_length:
+                return None  # Found a case with a different or unknown size
+
+        switch_key_size = self.switch_key.dop.get_static_bit_length()
+        if switch_key_size is None:
+            return None
+
+        return max(
+            switch_key_size + self.switch_key.byte_position * 8 +
+            (self.switch_key.bit_position or 0), case_bit_length + self.byte_position * 8)

odxtools/multiplexercase.py

@@ -6,19 +6,20 @@ from xml.etree import ElementTree
 from .compumethods.limit import Limit
 from .element import NamedElement
 from .exceptions import odxrequire
-from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef, resolve_snref
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkId, OdxLinkRef, resolve_snref
 from .odxtypes import AtomicOdxType, DataType
 from .snrefcontext import SnRefContext
 from .structure import Structure
 from .utils import dataclass_fields_asdict
 
 
-@dataclass
+@dataclass(kw_only=True)
 class MultiplexerCase(NamedElement):
     """This class represents a case which represents a range of keys of a multiplexer."""
 
-    structure_ref: OdxLinkRef | None
-    structure_snref: str | None
+    structure_ref: OdxLinkRef | None = None
+    structure_snref: str | None = None
     lower_limit: Limit
     upper_limit: Limit
 
@@ -27,23 +28,22 @@ class MultiplexerCase(NamedElement):
         return self._structure
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element,
-                doc_frags: list[OdxDocFragment]) -> "MultiplexerCase":
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "MultiplexerCase":
         """Reads a case for a Multiplexer."""
-        kwargs = dataclass_fields_asdict(NamedElement.from_et(et_element, doc_frags))
-        structure_ref = OdxLinkRef.from_et(et_element.find("STRUCTURE-REF"), doc_frags)
+        kwargs = dataclass_fields_asdict(NamedElement.from_et(et_element, context))
+        structure_ref = OdxLinkRef.from_et(et_element.find("STRUCTURE-REF"), context)
         structure_snref = None
         if (structure_snref_elem := et_element.find("STRUCTURE-SNREF")) is not None:
             structure_snref = odxrequire(structure_snref_elem.get("SHORT-NAME"))
 
         lower_limit = Limit.limit_from_et(
             odxrequire(et_element.find("LOWER-LIMIT")),
-            doc_frags,
+            context,
             value_type=None,
         )
         upper_limit = Limit.limit_from_et(
             odxrequire(et_element.find("UPPER-LIMIT")),
-            doc_frags,
+            context,
             value_type=None,
         )
 

odxtools/multiplexerdefaultcase.py

@@ -5,17 +5,18 @@ from xml.etree import ElementTree
 
 from .element import NamedElement
 from .exceptions import odxrequire
-from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef, resolve_snref
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkId, OdxLinkRef, resolve_snref
 from .snrefcontext import SnRefContext
 from .structure import Structure
 from .utils import dataclass_fields_asdict
 
 
-@dataclass
+@dataclass(kw_only=True)
 class MultiplexerDefaultCase(NamedElement):
     """This class represents a Default Case, which is selected when there are no cases defined in the Multiplexer."""
-    structure_ref: OdxLinkRef | None
-    structure_snref: str | None
+    structure_ref: OdxLinkRef | None = None
+    structure_snref: str | None = None
 
     @property
     def structure(self) -> Structure | None:
@@ -23,11 +24,11 @@ class MultiplexerDefaultCase(NamedElement):
 
     @staticmethod
     def from_et(et_element: ElementTree.Element,
-                doc_frags: list[OdxDocFragment]) -> "MultiplexerDefaultCase":
+                context: OdxDocContext) -> "MultiplexerDefaultCase":
         """Reads a default case for a multiplexer."""
-        kwargs = dataclass_fields_asdict(NamedElement.from_et(et_element, doc_frags))
+        kwargs = dataclass_fields_asdict(NamedElement.from_et(et_element, context))
 
-        structure_ref = OdxLinkRef.from_et(et_element.find("STRUCTURE-REF"), doc_frags)
+        structure_ref = OdxLinkRef.from_et(et_element.find("STRUCTURE-REF"), context)
         structure_snref = None
         if (structure_snref_elem := et_element.find("STRUCTURE-SNREF")) is not None:
             structure_snref = odxrequire(structure_snref_elem.get("SHORT-NAME"))

odxtools/multiplexerswitchkey.py

@@ -5,17 +5,18 @@ from xml.etree import ElementTree
 
 from .dataobjectproperty import DataObjectProperty
 from .exceptions import odxrequire
-from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkId, OdxLinkRef
 from .snrefcontext import SnRefContext
 
 
-@dataclass
+@dataclass(kw_only=True)
 class MultiplexerSwitchKey:
     """
     The object that determines the case to be used by a multiplexer
     """
     byte_position: int
-    bit_position: int | None
+    bit_position: int | None = None
     dop_ref: OdxLinkRef
 
     @property
@@ -23,12 +24,11 @@ class MultiplexerSwitchKey:
         return self._dop
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element,
-                doc_frags: list[OdxDocFragment]) -> "MultiplexerSwitchKey":
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "MultiplexerSwitchKey":
         byte_position = int(odxrequire(et_element.findtext("BYTE-POSITION")))
         bit_position_str = et_element.findtext("BIT-POSITION")
         bit_position = int(bit_position_str) if bit_position_str is not None else None
-        dop_ref = odxrequire(OdxLinkRef.from_et(et_element.find("DATA-OBJECT-PROP-REF"), doc_frags))
+        dop_ref = odxrequire(OdxLinkRef.from_et(et_element.find("DATA-OBJECT-PROP-REF"), context))
 
         return MultiplexerSwitchKey(
             byte_position=byte_position,

odxtools/nameditemlist.py

@@ -142,7 +142,7 @@ class ItemAttributeList(list[T]):
         ...
 
     def __getitem__(self, key: SupportsIndex | str | slice) -> T | list[T]:
-        if isinstance(key, SupportsIndex | slice):
+        if isinstance(key, (SupportsIndex, slice)):
             return super().__getitem__(key)
         else:
             return self._item_dict[key]

odxtools/negoutputparam.py

@@ -6,12 +6,13 @@ from xml.etree import ElementTree
 from .dopbase import DopBase
 from .element import NamedElement
 from .exceptions import odxrequire
-from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkId, OdxLinkRef
 from .snrefcontext import SnRefContext
 from .utils import dataclass_fields_asdict
 
 
-@dataclass
+@dataclass(kw_only=True)
 class NegOutputParam(NamedElement):
     dop_base_ref: OdxLinkRef
 
@@ -21,11 +22,10 @@ class NegOutputParam(NamedElement):
         return self._dop
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element,
-                doc_frags: list[OdxDocFragment]) -> "NegOutputParam":
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "NegOutputParam":
 
-        kwargs = dataclass_fields_asdict(NamedElement.from_et(et_element, doc_frags))
-        dop_base_ref = odxrequire(OdxLinkRef.from_et(et_element.find("DOP-BASE-REF"), doc_frags))
+        kwargs = dataclass_fields_asdict(NamedElement.from_et(et_element, context))
+        dop_base_ref = odxrequire(OdxLinkRef.from_et(et_element.find("DOP-BASE-REF"), context))
 
         return NegOutputParam(dop_base_ref=dop_base_ref, **kwargs)
 

odxtools/odxcategory.py

@@ -1,14 +1,14 @@
 # SPDX-License-Identifier: MIT
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from typing import TYPE_CHECKING, Any
 from xml.etree import ElementTree
 
 from .admindata import AdminData
 from .companydata import CompanyData
 from .element import IdentifiableElement
-from .exceptions import odxrequire
 from .nameditemlist import NamedItemList
-from .odxlink import DocType, OdxDocFragment, OdxLinkDatabase, OdxLinkId
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkId
 from .snrefcontext import SnRefContext
 from .specialdatagroup import SpecialDataGroup
 from .utils import dataclass_fields_asdict
@@ -17,37 +17,25 @@ if TYPE_CHECKING:
     from .database import Database
 
 
-@dataclass
+@dataclass(kw_only=True)
 class OdxCategory(IdentifiableElement):
     """This is the base class for all top-level container classes in ODX"""
 
-    admin_data: AdminData | None
-    company_datas: NamedItemList[CompanyData]
-    sdgs: list[SpecialDataGroup]
+    admin_data: AdminData | None = None
+    company_datas: NamedItemList[CompanyData] = field(default_factory=NamedItemList)
+    sdgs: list[SpecialDataGroup] = field(default_factory=list)
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element, doc_frags: list[OdxDocFragment]) -> "OdxCategory":
-        raise Exception("Calling `._from_et()` is not allowed for OdxCategory. "
-                        "Use `OdxCategory.category_from_et()`!")
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "OdxCategory":
 
-    @staticmethod
-    def category_from_et(et_element: ElementTree.Element, doc_frags: list[OdxDocFragment], *,
-                         doc_type: DocType) -> "OdxCategory":
-
-        short_name = odxrequire(et_element.findtext("SHORT-NAME"))
-        # create the current ODX "document fragment" (description of the
-        # current document for references and IDs)
-        doc_frags = [OdxDocFragment(short_name, doc_type)]
-        kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, doc_frags))
+        kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, context))
 
-        admin_data = AdminData.from_et(et_element.find("ADMIN-DATA"), doc_frags)
+        admin_data = AdminData.from_et(et_element.find("ADMIN-DATA"), context)
         company_datas = NamedItemList([
-            CompanyData.from_et(cde, doc_frags)
+            CompanyData.from_et(cde, context)
             for cde in et_element.iterfind("COMPANY-DATAS/COMPANY-DATA")
         ])
-        sdgs = [
-            SpecialDataGroup.from_et(sdge, doc_frags) for sdge in et_element.iterfind("SDGS/SDG")
-        ]
+        sdgs = [SpecialDataGroup.from_et(sdge, context) for sdge in et_element.iterfind("SDGS/SDG")]
 
         return OdxCategory(admin_data=admin_data, company_datas=company_datas, sdgs=sdgs, **kwargs)
 

odxtools/odxdoccontext.py

@@ -0,0 +1,16 @@
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+from packaging.version import Version
+
+if TYPE_CHECKING:
+    from odxtools.odxlink import OdxDocFragment
+
+
+@dataclass(slots=True, frozen=True)
+class OdxDocContext:
+    version: Version
+
+    # the doc_fragments are either tuple(doc_frag(category),)
+    # or tuple(doc_frag(category), doc_frag(diag_layer))
+    doc_fragments: tuple["OdxDocFragment"] | tuple["OdxDocFragment", "OdxDocFragment"]