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

odxtools/dataobjectproperty.py

@@ -12,7 +12,8 @@ from .dopbase import DopBase
 from .encodestate import EncodeState
 from .exceptions import EncodeError, odxraise, odxrequire
 from .internalconstr import InternalConstr
-from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkId, OdxLinkRef
 from .odxtypes import AtomicOdxType, BytesTypes, ParameterValue
 from .physicaltype import PhysicalType
 from .snrefcontext import SnRefContext
@@ -20,7 +21,7 @@ from .unit import Unit
 from .utils import dataclass_fields_asdict
 
 
-@dataclass
+@dataclass(kw_only=True)
 class DataObjectProperty(DopBase):
     """This class represents a DATA-OBJECT-PROP.
 
@@ -37,42 +38,40 @@ class DataObjectProperty(DopBase):
     #: The type of the value in the physical world
     physical_type: PhysicalType
 
-    internal_constr: InternalConstr | None
+    internal_constr: InternalConstr | None = None
 
     #: The unit associated with physical values (e.g. 'm/s^2')
-    unit_ref: OdxLinkRef | None
+    unit_ref: OdxLinkRef | None = None
 
-    physical_constr: InternalConstr | None
+    physical_constr: InternalConstr | None = None
 
     @property
     def unit(self) -> Unit | None:
         return self._unit
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element,
-                doc_frags: list[OdxDocFragment]) -> "DataObjectProperty":
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "DataObjectProperty":
         """Reads a DATA-OBJECT-PROP."""
-        kwargs = dataclass_fields_asdict(DopBase.from_et(et_element, doc_frags))
+        kwargs = dataclass_fields_asdict(DopBase.from_et(et_element, context))
 
         diag_coded_type = create_any_diag_coded_type_from_et(
-            odxrequire(et_element.find("DIAG-CODED-TYPE")), doc_frags)
-        physical_type = PhysicalType.from_et(
-            odxrequire(et_element.find("PHYSICAL-TYPE")), doc_frags)
+            odxrequire(et_element.find("DIAG-CODED-TYPE")), context)
+        physical_type = PhysicalType.from_et(odxrequire(et_element.find("PHYSICAL-TYPE")), context)
         compu_method = create_any_compu_method_from_et(
             odxrequire(et_element.find("COMPU-METHOD")),
-            doc_frags,
+            context,
             internal_type=diag_coded_type.base_data_type,
             physical_type=physical_type.base_data_type,
         )
         internal_constr = None
         if (internal_constr_elem := et_element.find("INTERNAL-CONSTR")) is not None:
             internal_constr = InternalConstr.constr_from_et(
-                internal_constr_elem, doc_frags, value_type=diag_coded_type.base_data_type)
-        unit_ref = OdxLinkRef.from_et(et_element.find("UNIT-REF"), doc_frags)
+                internal_constr_elem, context, value_type=diag_coded_type.base_data_type)
+        unit_ref = OdxLinkRef.from_et(et_element.find("UNIT-REF"), context)
         physical_constr = None
         if (physical_constr_elem := et_element.find("PHYS-CONSTR")) is not None:
             physical_constr = InternalConstr.constr_from_et(
-                physical_constr_elem, doc_frags, value_type=physical_type.base_data_type)
+                physical_constr_elem, context, value_type=physical_type.base_data_type)
 
         return DataObjectProperty(
             compu_method=compu_method,
@@ -118,7 +117,7 @@ class DataObjectProperty(DopBase):
                 f"The value {repr(physical_value)} of type {type(physical_value).__name__}"
                 f" is not a valid.")
 
-        if not isinstance(physical_value, int | float | str | BytesTypes):
+        if not isinstance(physical_value, (int, float, str, BytesTypes)):
             odxraise(f"Invalid type '{type(physical_value).__name__}' for physical value. "
                      f"(Expect atomic type!)")
         internal_value = self.compu_method.convert_physical_to_internal(physical_value)

odxtools/description.py

@@ -1,22 +1,22 @@
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from typing import Optional
 from xml.etree import ElementTree
 
 from .exceptions import odxrequire
 from .externaldoc import ExternalDoc
-from .odxlink import OdxDocFragment
+from .odxdoccontext import OdxDocContext
 
 
-@dataclass
+@dataclass(kw_only=True)
 class Description:
     text: str
-    external_docs: list[ExternalDoc]
+    external_docs: list[ExternalDoc] = field(default_factory=list)
 
-    text_identifier: str | None
+    text_identifier: str | None = None
 
     @staticmethod
     def from_et(et_element: ElementTree.Element | None,
-                doc_frags: list[OdxDocFragment]) -> Optional["Description"]:
+                context: OdxDocContext) -> Optional["Description"]:
         if et_element is None:
             return None
 
@@ -35,7 +35,7 @@ class Description:
 
         external_docs = \
             [
-                odxrequire(ExternalDoc.from_et(ed, doc_frags)) for ed in et_element.iterfind("EXTERNAL-DOCS/EXTERNAL-DOC")
+                odxrequire(ExternalDoc.from_et(ed, context)) for ed in et_element.iterfind("EXTERNAL-DOCS/EXTERNAL-DOC")
             ]
 
         text_identifier = et_element.attrib.get("TI")

odxtools/determinenumberofitems.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 DetermineNumberOfItems:
     """
     The object that determines the number of items of dynamic fields
     """
     byte_position: int
-    bit_position: int | None
+    bit_position: int | None = None
     dop_ref: OdxLinkRef
 
     @property
@@ -24,11 +25,11 @@ class DetermineNumberOfItems:
 
     @staticmethod
     def from_et(et_element: ElementTree.Element,
-                doc_frags: list[OdxDocFragment]) -> "DetermineNumberOfItems":
+                context: OdxDocContext) -> "DetermineNumberOfItems":
         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 DetermineNumberOfItems(
             byte_position=byte_position,

odxtools/diagcodedtype.py

@@ -7,7 +7,8 @@ from .decodestate import DecodeState
 from .encodestate import EncodeState
 from .encoding import Encoding
 from .exceptions import odxassert, odxraise, odxrequire
-from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkId
 from .odxtypes import AtomicOdxType, DataType, odxstr_to_bool
 from .snrefcontext import SnRefContext
 
@@ -20,12 +21,12 @@ DctType = Literal[
 ]
 
 
-@dataclass
+@dataclass(kw_only=True)
 class DiagCodedType:
-    base_type_encoding: Encoding | None
+    base_type_encoding: Encoding | None = None
     base_data_type: DataType
 
-    is_highlow_byte_order_raw: bool | None
+    is_highlow_byte_order_raw: bool | None = None
 
     @property
     def dct_type(self) -> DctType:
@@ -38,8 +39,7 @@ class DiagCodedType:
         return self.is_highlow_byte_order_raw in [None, True]
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element,
-                doc_frags: list[OdxDocFragment]) -> "DiagCodedType":
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "DiagCodedType":
         base_type_encoding = None
         if (base_type_encoding_str := et_element.get("BASE-TYPE-ENCODING")) is not None:
             try:

odxtools/diagcomm.py

@@ -1,5 +1,5 @@
 # SPDX-License-Identifier: MIT
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from typing import TYPE_CHECKING, Any
 from xml.etree import ElementTree
 
@@ -10,7 +10,8 @@ from .element import IdentifiableElement
 from .exceptions import odxraise, odxrequire
 from .functionalclass import FunctionalClass
 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 .odxtypes import odxstr_to_bool
 from .preconditionstateref import PreConditionStateRef
 from .relateddiagcommref import RelatedDiagCommRef
@@ -25,7 +26,7 @@ if TYPE_CHECKING:
     from .diaglayers.protocol import Protocol
 
 
-@dataclass
+@dataclass(kw_only=True)
 class DiagComm(IdentifiableElement):
     """Representation of a diagnostic communication object.
 
@@ -34,21 +35,21 @@ class DiagComm(IdentifiableElement):
 
     """
 
-    admin_data: AdminData | None
-    sdgs: list[SpecialDataGroup]
-    functional_class_refs: list[OdxLinkRef]
-    audience: Audience | None
-    protocol_snrefs: list[str]
-    related_diag_comm_refs: list[RelatedDiagCommRef]
-    pre_condition_state_refs: list[PreConditionStateRef]
-    state_transition_refs: list[StateTransitionRef]
+    admin_data: AdminData | None = None
+    sdgs: list[SpecialDataGroup] = field(default_factory=list)
+    functional_class_refs: list[OdxLinkRef] = field(default_factory=list)
+    audience: Audience | None = None
+    protocol_snrefs: list[str] = field(default_factory=list)
+    related_diag_comm_refs: list[RelatedDiagCommRef] = field(default_factory=list)
+    pre_condition_state_refs: list[PreConditionStateRef] = field(default_factory=list)
+    state_transition_refs: list[StateTransitionRef] = field(default_factory=list)
 
     # attributes
-    semantic: str | None
-    diagnostic_class: DiagClassType | None
-    is_mandatory_raw: bool | None
-    is_executable_raw: bool | None
-    is_final_raw: bool | None
+    semantic: str | None = None
+    diagnostic_class: DiagClassType | None = None
+    is_mandatory_raw: bool | None = None
+    is_executable_raw: bool | None = None
+    is_final_raw: bool | None = None
 
     @property
     def functional_classes(self) -> NamedItemList[FunctionalClass]:
@@ -83,22 +84,20 @@ class DiagComm(IdentifiableElement):
         return self.is_final_raw is True
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element, doc_frags: list[OdxDocFragment]) -> "DiagComm":
-        kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, doc_frags))
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "DiagComm":
+        kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, context))
 
-        admin_data = AdminData.from_et(et_element.find("ADMIN-DATA"), doc_frags)
-        sdgs = [
-            SpecialDataGroup.from_et(sdge, doc_frags) for sdge in et_element.iterfind("SDGS/SDG")
-        ]
+        admin_data = AdminData.from_et(et_element.find("ADMIN-DATA"), context)
+        sdgs = [SpecialDataGroup.from_et(sdge, context) for sdge in et_element.iterfind("SDGS/SDG")]
 
         functional_class_refs = [
-            odxrequire(OdxLinkRef.from_et(el, doc_frags))
+            odxrequire(OdxLinkRef.from_et(el, context))
             for el in et_element.iterfind("FUNCT-CLASS-REFS/FUNCT-CLASS-REF")
         ]
 
         audience = None
         if (audience_elem := et_element.find("AUDIENCE")) is not None:
-            audience = Audience.from_et(audience_elem, doc_frags)
+            audience = Audience.from_et(audience_elem, context)
 
         protocol_snrefs = [
             odxrequire(el.get("SHORT-NAME"))
@@ -106,17 +105,17 @@ class DiagComm(IdentifiableElement):
         ]
 
         related_diag_comm_refs = [
-            RelatedDiagCommRef.from_et(el, doc_frags)
+            RelatedDiagCommRef.from_et(el, context)
             for el in et_element.iterfind("RELATED-DIAG-COMM-REFS/RELATED-DIAG-COMM-REF")
         ]
 
         pre_condition_state_refs = [
-            PreConditionStateRef.from_et(el, doc_frags)
+            PreConditionStateRef.from_et(el, context)
             for el in et_element.iterfind("PRE-CONDITION-STATE-REFS/PRE-CONDITION-STATE-REF")
         ]
 
         state_transition_refs = [
-            StateTransitionRef.from_et(el, doc_frags)
+            StateTransitionRef.from_et(el, context)
             for el in et_element.iterfind("STATE-TRANSITION-REFS/STATE-TRANSITION-REF")
         ]
 

odxtools/diagdatadictionaryspec.py

@@ -1,5 +1,5 @@
 # SPDX-License-Identifier: MIT
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from itertools import chain
 from typing import Any
 from xml.etree import ElementTree
@@ -15,7 +15,8 @@ from .environmentdata import EnvironmentData
 from .environmentdatadescription import EnvironmentDataDescription
 from .multiplexer import Multiplexer
 from .nameditemlist import NamedItemList
-from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkId
 from .snrefcontext import SnRefContext
 from .specialdatagroup import SpecialDataGroup
 from .staticfield import StaticField
@@ -24,72 +25,73 @@ from .table import Table
 from .unitspec import UnitSpec
 
 
-@dataclass
+@dataclass(kw_only=True)
 class DiagDataDictionarySpec:
-    admin_data: AdminData | None
-    dtc_dops: NamedItemList[DtcDop]
-    env_data_descs: NamedItemList[EnvironmentDataDescription]
-    data_object_props: NamedItemList[DataObjectProperty]
-    structures: NamedItemList[Structure]
-    static_fields: NamedItemList[StaticField]
-    dynamic_length_fields: NamedItemList[DynamicLengthField]
-    dynamic_endmarker_fields: NamedItemList[DynamicEndmarkerField]
-    end_of_pdu_fields: NamedItemList[EndOfPduField]
-    muxs: NamedItemList[Multiplexer]
-    env_datas: NamedItemList[EnvironmentData]
-    unit_spec: UnitSpec | None
-    tables: NamedItemList[Table]
-    sdgs: list[SpecialDataGroup]
+    admin_data: AdminData | None = None
+    dtc_dops: NamedItemList[DtcDop] = field(default_factory=NamedItemList)
+    env_data_descs: NamedItemList[EnvironmentDataDescription] = field(default_factory=NamedItemList)
+    data_object_props: NamedItemList[DataObjectProperty] = field(default_factory=NamedItemList)
+    structures: NamedItemList[Structure] = field(default_factory=NamedItemList)
+    static_fields: NamedItemList[StaticField] = field(default_factory=NamedItemList)
+    dynamic_length_fields: NamedItemList[DynamicLengthField] = field(default_factory=NamedItemList)
+    dynamic_endmarker_fields: NamedItemList[DynamicEndmarkerField] = field(
+        default_factory=NamedItemList)
+    end_of_pdu_fields: NamedItemList[EndOfPduField] = field(default_factory=NamedItemList)
+    muxs: NamedItemList[Multiplexer] = field(default_factory=NamedItemList)
+    env_datas: NamedItemList[EnvironmentData] = field(default_factory=NamedItemList)
+    unit_spec: UnitSpec | None = None
+    tables: NamedItemList[Table] = field(default_factory=NamedItemList)
+    sdgs: list[SpecialDataGroup] = field(default_factory=list)
 
     @staticmethod
     def from_et(et_element: ElementTree.Element,
-                doc_frags: list[OdxDocFragment]) -> "DiagDataDictionarySpec":
+                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, doc_frags)
+            admin_data = AdminData.from_et(admin_data_elem, context)
 
         dtc_dops = NamedItemList([
-            DtcDop.from_et(dtc_dop_elem, doc_frags)
+            DtcDop.from_et(dtc_dop_elem, context)
             for dtc_dop_elem in et_element.iterfind("DTC-DOPS/DTC-DOP")
         ])
 
         env_data_descs = NamedItemList([
-            EnvironmentDataDescription.from_et(env_data_desc_element, doc_frags)
+            EnvironmentDataDescription.from_et(env_data_desc_element, context)
             for env_data_desc_element in et_element.iterfind("ENV-DATA-DESCS/ENV-DATA-DESC")
         ])
 
         data_object_props = NamedItemList([
-            DataObjectProperty.from_et(dop_element, doc_frags)
+            DataObjectProperty.from_et(dop_element, context)
             for dop_element in et_element.iterfind("DATA-OBJECT-PROPS/DATA-OBJECT-PROP")
         ])
 
         structures = NamedItemList([
-            Structure.from_et(structure_element, doc_frags)
+            Structure.from_et(structure_element, context)
             for structure_element in et_element.iterfind("STRUCTURES/STRUCTURE")
         ])
 
         static_fields = NamedItemList([
-            StaticField.from_et(dl_element, doc_frags)
+            StaticField.from_et(dl_element, context)
             for dl_element in et_element.iterfind("STATIC-FIELDS/STATIC-FIELD")
         ])
 
         dynamic_length_fields = NamedItemList([
-            DynamicLengthField.from_et(dl_element, doc_frags)
+            DynamicLengthField.from_et(dl_element, context)
             for dl_element in et_element.iterfind("DYNAMIC-LENGTH-FIELDS/DYNAMIC-LENGTH-FIELD")
         ])
 
         dynamic_endmarker_fields = NamedItemList([
-            DynamicEndmarkerField.from_et(dl_element, doc_frags) for dl_element in
+            DynamicEndmarkerField.from_et(dl_element, context) for dl_element in
             et_element.iterfind("DYNAMIC-ENDMARKER-FIELDS/DYNAMIC-ENDMARKER-FIELD")
         ])
 
         end_of_pdu_fields = NamedItemList([
-            EndOfPduField.from_et(eofp_element, doc_frags)
+            EndOfPduField.from_et(eofp_element, context)
             for eofp_element in et_element.iterfind("END-OF-PDU-FIELDS/END-OF-PDU-FIELD")
         ])
 
         muxs = NamedItemList([
-            Multiplexer.from_et(mux_element, doc_frags)
+            Multiplexer.from_et(mux_element, context)
             for mux_element in et_element.iterfind("MUXS/MUX")
         ])
 
@@ -99,23 +101,21 @@ class DiagDataDictionarySpec:
             et_element.iterfind("ENV-DATA-DESCS/ENV-DATA-DESC/ENV-DATAS/ENV-DATA"),
         )
         env_datas = NamedItemList([
-            EnvironmentData.from_et(env_data_element, doc_frags)
+            EnvironmentData.from_et(env_data_element, context)
             for env_data_element in env_data_elements
         ])
 
         if (spec_elem := et_element.find("UNIT-SPEC")) is not None:
-            unit_spec = UnitSpec.from_et(spec_elem, doc_frags)
+            unit_spec = UnitSpec.from_et(spec_elem, context)
         else:
             unit_spec = None
 
         tables = NamedItemList([
-            Table.from_et(table_element, doc_frags)
+            Table.from_et(table_element, context)
             for table_element in et_element.iterfind("TABLES/TABLE")
         ])
 
-        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 DiagDataDictionarySpec(
             admin_data=admin_data,

odxtools/diaglayercontainer.py

@@ -1,5 +1,5 @@
 # SPDX-License-Identifier: MIT
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from itertools import chain
 from typing import TYPE_CHECKING, Any
 from xml.etree import ElementTree
@@ -10,8 +10,10 @@ from .diaglayers.ecushareddata import EcuSharedData
 from .diaglayers.ecuvariant import EcuVariant
 from .diaglayers.functionalgroup import FunctionalGroup
 from .diaglayers.protocol import Protocol
+from .exceptions import odxrequire
 from .nameditemlist import NamedItemList
 from .odxcategory import OdxCategory
+from .odxdoccontext import OdxDocContext
 from .odxlink import DocType, OdxDocFragment, OdxLinkDatabase, OdxLinkId
 from .snrefcontext import SnRefContext
 from .utils import dataclass_fields_asdict
@@ -20,13 +22,13 @@ if TYPE_CHECKING:
     from .database import Database
 
 
-@dataclass
+@dataclass(kw_only=True)
 class DiagLayerContainer(OdxCategory):
-    protocols: NamedItemList[Protocol]
-    functional_groups: NamedItemList[FunctionalGroup]
-    ecu_shared_datas: NamedItemList[EcuSharedData]
-    base_variants: NamedItemList[BaseVariant]
-    ecu_variants: NamedItemList[EcuVariant]
+    protocols: NamedItemList[Protocol] = field(default_factory=NamedItemList)
+    functional_groups: NamedItemList[FunctionalGroup] = field(default_factory=NamedItemList)
+    ecu_shared_datas: NamedItemList[EcuSharedData] = field(default_factory=NamedItemList)
+    base_variants: NamedItemList[BaseVariant] = field(default_factory=NamedItemList)
+    ecu_variants: NamedItemList[EcuVariant] = field(default_factory=NamedItemList)
 
     @property
     def diag_layers(self) -> NamedItemList[DiagLayer]:
@@ -40,33 +42,32 @@ class DiagLayerContainer(OdxCategory):
         return self.ecu_variants
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element,
-                doc_frags: list[OdxDocFragment]) -> "DiagLayerContainer":
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "DiagLayerContainer":
 
-        cat = OdxCategory.category_from_et(et_element, doc_frags, doc_type=DocType.CONTAINER)
-        doc_frags = cat.odx_id.doc_fragments
+        cat = OdxCategory.from_et(et_element, context)
         kwargs = dataclass_fields_asdict(cat)
 
-        protocols = NamedItemList([
-            Protocol.from_et(dl_element, doc_frags)
-            for dl_element in et_element.iterfind("PROTOCOLS/PROTOCOL")
-        ])
-        functional_groups = NamedItemList([
-            FunctionalGroup.from_et(dl_element, doc_frags)
-            for dl_element in et_element.iterfind("FUNCTIONAL-GROUPS/FUNCTIONAL-GROUP")
-        ])
-        ecu_shared_datas = NamedItemList([
-            EcuSharedData.from_et(dl_element, doc_frags)
-            for dl_element in et_element.iterfind("ECU-SHARED-DATAS/ECU-SHARED-DATA")
-        ])
-        base_variants = NamedItemList([
-            BaseVariant.from_et(dl_element, doc_frags)
-            for dl_element in et_element.iterfind("BASE-VARIANTS/BASE-VARIANT")
-        ])
-        ecu_variants = NamedItemList([
-            EcuVariant.from_et(dl_element, doc_frags)
-            for dl_element in et_element.iterfind("ECU-VARIANTS/ECU-VARIANT")
-        ])
+        def get_layer_context(diag_layer_et: ElementTree.Element) -> OdxDocContext:
+            layer_sn = odxrequire(diag_layer_et.findtext("SHORT-NAME"))
+            layer_docfrag = OdxDocFragment(layer_sn, DocType.LAYER)
+            # add layer doc fragment to container doc fragment
+            return OdxDocContext(context.version, (context.doc_fragments[0], layer_docfrag))
+
+        protocols = NamedItemList(
+            Protocol.from_et(layer_et, get_layer_context(layer_et))
+            for layer_et in et_element.iterfind("PROTOCOLS/PROTOCOL"))
+        functional_groups = NamedItemList(
+            FunctionalGroup.from_et(layer_et, get_layer_context(layer_et))
+            for layer_et in et_element.iterfind("FUNCTIONAL-GROUPS/FUNCTIONAL-GROUP"))
+        ecu_shared_datas = NamedItemList(
+            EcuSharedData.from_et(layer_et, get_layer_context(layer_et))
+            for layer_et in et_element.iterfind("ECU-SHARED-DATAS/ECU-SHARED-DATA"))
+        base_variants = NamedItemList(
+            BaseVariant.from_et(layer_et, get_layer_context(layer_et))
+            for layer_et in et_element.iterfind("BASE-VARIANTS/BASE-VARIANT"))
+        ecu_variants = NamedItemList(
+            EcuVariant.from_et(layer_et, get_layer_context(layer_et))
+            for layer_et in et_element.iterfind("ECU-VARIANTS/ECU-VARIANT"))
 
         return DiagLayerContainer(
             protocols=protocols,

odxtools/diaglayers/basevariant.py

@@ -12,7 +12,8 @@ from ..diagvariable import DiagVariable
 from ..dyndefinedspec import DynDefinedSpec
 from ..exceptions import odxassert
 from ..nameditemlist import NamedItemList
-from ..odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkRef
+from ..odxdoccontext import OdxDocContext
+from ..odxlink import OdxLinkDatabase, OdxLinkRef
 from ..parentref import ParentRef
 from ..variablegroup import VariableGroup
 from .basevariantraw import BaseVariantRaw
@@ -20,7 +21,7 @@ from .diaglayer import DiagLayer
 from .hierarchyelement import HierarchyElement
 
 
-@dataclass
+@dataclass(kw_only=True)
 class BaseVariant(HierarchyElement):
     """This is a diagnostic layer for common functionality of an ECU
     """
@@ -68,8 +69,8 @@ class BaseVariant(HierarchyElement):
     #######
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element, doc_frags: list[OdxDocFragment]) -> "BaseVariant":
-        base_variant_raw = BaseVariantRaw.from_et(et_element, doc_frags)
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "BaseVariant":
+        base_variant_raw = BaseVariantRaw.from_et(et_element, context)
 
         return BaseVariant(diag_layer_raw=base_variant_raw)