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

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)
 

odxtools/diaglayers/basevariantraw.py

@@ -1,5 +1,5 @@
 # SPDX-License-Identifier: MIT
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from typing import Any
 from xml.etree import ElementTree
 
@@ -8,7 +8,8 @@ from ..diagvariable import DiagVariable
 from ..dyndefinedspec import DynDefinedSpec
 from ..exceptions import odxraise
 from ..nameditemlist import NamedItemList
-from ..odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef
+from ..odxdoccontext import OdxDocContext
+from ..odxlink import OdxLinkDatabase, OdxLinkId, OdxLinkRef
 from ..parentref import ParentRef
 from ..snrefcontext import SnRefContext
 from ..utils import dataclass_fields_asdict
@@ -16,60 +17,58 @@ from ..variablegroup import VariableGroup
 from .hierarchyelementraw import HierarchyElementRaw
 
 
-@dataclass
+@dataclass(kw_only=True)
 class BaseVariantRaw(HierarchyElementRaw):
     """This is a diagnostic layer for common functionality of an ECU
     """
 
-    diag_variables_raw: list[DiagVariable | OdxLinkRef]
-    variable_groups: NamedItemList[VariableGroup]
-    dyn_defined_spec: DynDefinedSpec | None
-    base_variant_pattern: BaseVariantPattern | None
-    parent_refs: list[ParentRef]
+    diag_variables_raw: list[DiagVariable | OdxLinkRef] = field(default_factory=list)
+    variable_groups: NamedItemList[VariableGroup] = field(default_factory=NamedItemList)
+    dyn_defined_spec: DynDefinedSpec | None = None
+    base_variant_pattern: BaseVariantPattern | None = None
+    parent_refs: list[ParentRef] = field(default_factory=list)
 
     @property
     def diag_variables(self) -> NamedItemList[DiagVariable]:
         return self._diag_variables
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element,
-                doc_frags: list[OdxDocFragment]) -> "BaseVariantRaw":
-        # objects contained by diagnostic layers exibit an additional
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "BaseVariantRaw":
+        # objects contained by diagnostic layers exhibit an additional
         # document fragment for the diag layer, so we use the document
         # fragments of the odx id of the diag layer for IDs of
         # contained objects.
-        her = HierarchyElementRaw.from_et(et_element, doc_frags)
+        her = HierarchyElementRaw.from_et(et_element, context)
         kwargs = dataclass_fields_asdict(her)
-        doc_frags = her.odx_id.doc_fragments
 
         diag_variables_raw: list[DiagVariable | OdxLinkRef] = []
         if (dv_elems := et_element.find("DIAG-VARIABLES")) is not None:
             for dv_proxy_elem in dv_elems:
                 dv_proxy: OdxLinkRef | DiagVariable
                 if dv_proxy_elem.tag == "DIAG-VARIABLE-REF":
-                    dv_proxy = OdxLinkRef.from_et(dv_proxy_elem, doc_frags)
+                    dv_proxy = OdxLinkRef.from_et(dv_proxy_elem, context)
                 elif dv_proxy_elem.tag == "DIAG-VARIABLE":
-                    dv_proxy = DiagVariable.from_et(dv_proxy_elem, doc_frags)
+                    dv_proxy = DiagVariable.from_et(dv_proxy_elem, context)
                 else:
                     odxraise()
 
                 diag_variables_raw.append(dv_proxy)
 
         variable_groups = NamedItemList([
-            VariableGroup.from_et(vg_elem, doc_frags)
+            VariableGroup.from_et(vg_elem, context)
             for vg_elem in et_element.iterfind("VARIABLE-GROUPS/VARIABLE-GROUP")
         ])
 
         dyn_defined_spec = None
         if (dds_elem := et_element.find("DYN-DEFINED-SPEC")) is not None:
-            dyn_defined_spec = DynDefinedSpec.from_et(dds_elem, doc_frags)
+            dyn_defined_spec = DynDefinedSpec.from_et(dds_elem, context)
 
         base_variant_pattern = None
         if (bvp_elem := et_element.find("BASE-VARIANT-PATTERN")) is not None:
-            base_variant_pattern = BaseVariantPattern.from_et(bvp_elem, doc_frags)
+            base_variant_pattern = BaseVariantPattern.from_et(bvp_elem, context)
 
         parent_refs = [
-            ParentRef.from_et(pr_elem, doc_frags)
+            ParentRef.from_et(pr_elem, context)
             for pr_elem in et_element.iterfind("PARENT-REFS/PARENT-REF")
         ]
 

odxtools/diaglayers/diaglayer.py

@@ -17,7 +17,8 @@ from ..exceptions import DecodeError, odxassert, odxraise
 from ..library import Library
 from ..message import Message
 from ..nameditemlist import NamedItemList, TNamed
-from ..odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef
+from ..odxdoccontext import OdxDocContext
+from ..odxlink import OdxLinkDatabase, OdxLinkId, OdxLinkRef
 from ..parentref import ParentRef
 from ..request import Request
 from ..response import Response
@@ -33,7 +34,7 @@ from .diaglayertype import DiagLayerType
 PrefixTree = dict[int, Union[list[DiagService], "PrefixTree"]]
 
 
-@dataclass
+@dataclass(kw_only=True)
 class DiagLayer:
     """This class represents a "logical view" upon a diagnostic layer
     according to the ODX standard.
@@ -45,8 +46,8 @@ class DiagLayer:
     diag_layer_raw: DiagLayerRaw
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element, doc_frags: list[OdxDocFragment]) -> "DiagLayer":
-        diag_layer_raw = DiagLayerRaw.from_et(et_element, doc_frags)
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "DiagLayer":
+        diag_layer_raw = DiagLayerRaw.from_et(et_element, context)
 
         # Create DiagLayer
         return DiagLayer(diag_layer_raw=diag_layer_raw)