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

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)

odxtools/diaglayers/diaglayerraw.py

@@ -1,6 +1,5 @@
 # SPDX-License-Identifier: MIT
-from copy import copy
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from typing import Any, cast
 from xml.etree import ElementTree
 
@@ -11,11 +10,12 @@ from ..diagcomm import DiagComm
 from ..diagdatadictionaryspec import DiagDataDictionarySpec
 from ..diagservice import DiagService
 from ..element import IdentifiableElement
-from ..exceptions import odxassert, odxraise, odxrequire
+from ..exceptions import odxassert, odxraise
 from ..functionalclass import FunctionalClass
 from ..library import Library
 from ..nameditemlist import NamedItemList
-from ..odxlink import DocType, OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef
+from ..odxdoccontext import OdxDocContext
+from ..odxlink import OdxLinkDatabase, OdxLinkId, OdxLinkRef
 from ..request import Request
 from ..response import Response
 from ..singleecujob import SingleEcuJob
@@ -27,7 +27,7 @@ from ..utils import dataclass_fields_asdict
 from .diaglayertype import DiagLayerType
 
 
-@dataclass
+@dataclass(kw_only=True)
 class DiagLayerRaw(IdentifiableElement):
     """This class internalizes all data represented by the DIAG-LAYER
     XML tag and its derivatives.
@@ -36,21 +36,21 @@ class DiagLayerRaw(IdentifiableElement):
     """
 
     variant_type: DiagLayerType
-    admin_data: AdminData | None
-    company_datas: NamedItemList[CompanyData]
-    functional_classes: NamedItemList[FunctionalClass]
-    diag_data_dictionary_spec: DiagDataDictionarySpec | None
-    diag_comms_raw: list[OdxLinkRef | DiagComm]
-    requests: NamedItemList[Request]
-    positive_responses: NamedItemList[Response]
-    negative_responses: NamedItemList[Response]
-    global_negative_responses: NamedItemList[Response]
-    import_refs: list[OdxLinkRef]
-    state_charts: NamedItemList[StateChart]
-    additional_audiences: NamedItemList[AdditionalAudience]
-    sub_components: NamedItemList[SubComponent]
-    libraries: NamedItemList[Library]
-    sdgs: list[SpecialDataGroup]
+    admin_data: AdminData | None = None
+    company_datas: NamedItemList[CompanyData] = field(default_factory=NamedItemList)
+    functional_classes: NamedItemList[FunctionalClass] = field(default_factory=NamedItemList)
+    diag_data_dictionary_spec: DiagDataDictionarySpec | None = None
+    diag_comms_raw: list[OdxLinkRef | DiagComm] = field(default_factory=list)
+    requests: NamedItemList[Request] = field(default_factory=NamedItemList)
+    positive_responses: NamedItemList[Response] = field(default_factory=NamedItemList)
+    negative_responses: NamedItemList[Response] = field(default_factory=NamedItemList)
+    global_negative_responses: NamedItemList[Response] = field(default_factory=NamedItemList)
+    import_refs: list[OdxLinkRef] = field(default_factory=list)
+    state_charts: NamedItemList[StateChart] = field(default_factory=NamedItemList)
+    additional_audiences: NamedItemList[AdditionalAudience] = field(default_factory=NamedItemList)
+    sub_components: NamedItemList[SubComponent] = field(default_factory=NamedItemList)
+    libraries: NamedItemList[Library] = field(default_factory=NamedItemList)
+    sdgs: list[SpecialDataGroup] = field(default_factory=list)
 
     @property
     def diag_comms(self) -> NamedItemList[DiagComm]:
@@ -70,98 +70,89 @@ class DiagLayerRaw(IdentifiableElement):
         return self._single_ecu_jobs
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element, doc_frags: list[OdxDocFragment]) -> "DiagLayerRaw":
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "DiagLayerRaw":
         try:
             variant_type = DiagLayerType(et_element.tag)
         except ValueError:
             variant_type = cast(DiagLayerType, None)
             odxraise(f"Encountered unknown diagnostic layer type '{et_element.tag}'")
 
-        short_name = odxrequire(et_element.findtext("SHORT-NAME"))
-
-        # extend the applicable ODX "document fragments" for the diag layer objects
-        doc_frags = copy(doc_frags)
-        doc_frags.append(OdxDocFragment(short_name, DocType.LAYER))
-        kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, doc_frags))
+        kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, context))
 
         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)
 
         company_datas = NamedItemList([
-            CompanyData.from_et(cd_el, doc_frags)
+            CompanyData.from_et(cd_el, context)
             for cd_el in et_element.iterfind("COMPANY-DATAS/COMPANY-DATA")
         ])
 
         functional_classes = NamedItemList([
-            FunctionalClass.from_et(fc_el, doc_frags)
+            FunctionalClass.from_et(fc_el, context)
             for fc_el in et_element.iterfind("FUNCT-CLASSS/FUNCT-CLASS")
         ])
 
         diag_data_dictionary_spec = None
         if (ddds_elem := et_element.find("DIAG-DATA-DICTIONARY-SPEC")) is not None:
-            diag_data_dictionary_spec = DiagDataDictionarySpec.from_et(ddds_elem, doc_frags)
+            diag_data_dictionary_spec = DiagDataDictionarySpec.from_et(ddds_elem, context)
 
         diag_comms_raw: list[OdxLinkRef | DiagComm] = []
         if (dc_elems := et_element.find("DIAG-COMMS")) is not None:
             for dc_proxy_elem in dc_elems:
                 dc: OdxLinkRef | DiagComm
                 if dc_proxy_elem.tag == "DIAG-COMM-REF":
-                    dc = OdxLinkRef.from_et(dc_proxy_elem, doc_frags)
+                    dc = OdxLinkRef.from_et(dc_proxy_elem, context)
                 elif dc_proxy_elem.tag == "DIAG-SERVICE":
-                    dc = DiagService.from_et(dc_proxy_elem, doc_frags)
+                    dc = DiagService.from_et(dc_proxy_elem, context)
                 else:
                     odxassert(dc_proxy_elem.tag == "SINGLE-ECU-JOB")
-                    dc = SingleEcuJob.from_et(dc_proxy_elem, doc_frags)
+                    dc = SingleEcuJob.from_et(dc_proxy_elem, context)
 
                 diag_comms_raw.append(dc)
 
         requests = NamedItemList([
-            Request.from_et(rq_elem, doc_frags)
-            for rq_elem in et_element.iterfind("REQUESTS/REQUEST")
+            Request.from_et(rq_elem, context) for rq_elem in et_element.iterfind("REQUESTS/REQUEST")
         ])
 
         positive_responses = NamedItemList([
-            Response.from_et(rs_elem, doc_frags)
+            Response.from_et(rs_elem, context)
             for rs_elem in et_element.iterfind("POS-RESPONSES/POS-RESPONSE")
         ])
 
         negative_responses = NamedItemList([
-            Response.from_et(rs_elem, doc_frags)
+            Response.from_et(rs_elem, context)
             for rs_elem in et_element.iterfind("NEG-RESPONSES/NEG-RESPONSE")
         ])
 
         global_negative_responses = NamedItemList([
-            Response.from_et(rs_elem, doc_frags)
+            Response.from_et(rs_elem, context)
             for rs_elem in et_element.iterfind("GLOBAL-NEG-RESPONSES/GLOBAL-NEG-RESPONSE")
         ])
 
         import_refs = [
-            OdxLinkRef.from_et(el, doc_frags)
-            for el in et_element.iterfind("IMPORT-REFS/IMPORT-REF")
+            OdxLinkRef.from_et(el, context) for el in et_element.iterfind("IMPORT-REFS/IMPORT-REF")
         ]
 
         state_charts = NamedItemList([
-            StateChart.from_et(el, doc_frags)
+            StateChart.from_et(el, context)
             for el in et_element.iterfind("STATE-CHARTS/STATE-CHART")
         ])
 
         additional_audiences = NamedItemList([
-            AdditionalAudience.from_et(el, doc_frags)
+            AdditionalAudience.from_et(el, context)
             for el in et_element.iterfind("ADDITIONAL-AUDIENCES/ADDITIONAL-AUDIENCE")
         ])
 
         sub_components = NamedItemList([
-            SubComponent.from_et(el, doc_frags)
+            SubComponent.from_et(el, context)
             for el in et_element.iterfind("SUB-COMPONENTS/SUB-COMPONENT")
         ])
 
         libraries = NamedItemList(
-            [Library.from_et(el, doc_frags) for el in et_element.iterfind("LIBRARYS/LIBRARY")])
+            [Library.from_et(el, context) for el in et_element.iterfind("LIBRARYS/LIBRARY")])
 
-        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")]
 
         # Create DiagLayer
         return DiagLayerRaw(

odxtools/diaglayers/ecushareddata.py

@@ -7,17 +7,18 @@ from xml.etree import ElementTree
 from ..diagvariable import DiagVariable
 from ..exceptions import odxassert
 from ..nameditemlist import NamedItemList
-from ..odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkRef
+from ..odxdoccontext import OdxDocContext
+from ..odxlink import OdxLinkDatabase, OdxLinkRef
 from ..snrefcontext import SnRefContext
 from ..variablegroup import VariableGroup
 from .diaglayer import DiagLayer
 from .ecushareddataraw import EcuSharedDataRaw
 
 if TYPE_CHECKING:
-    from .database import Database
+    from ..database import Database
 
 
-@dataclass
+@dataclass(kw_only=True)
 class EcuSharedData(DiagLayer):
     """This is a diagnostic layer for data shared across others
     """
@@ -39,9 +40,8 @@ class EcuSharedData(DiagLayer):
         return self.ecu_shared_data_raw.variable_groups
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element,
-                doc_frags: list[OdxDocFragment]) -> "EcuSharedData":
-        ecu_shared_data_raw = EcuSharedDataRaw.from_et(et_element, doc_frags)
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "EcuSharedData":
+        ecu_shared_data_raw = EcuSharedDataRaw.from_et(et_element, context)
 
         return EcuSharedData(diag_layer_raw=ecu_shared_data_raw)
 

odxtools/diaglayers/ecushareddataraw.py

@@ -1,56 +1,55 @@
 # SPDX-License-Identifier: MIT
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from typing import Any
 from xml.etree import ElementTree
 
 from ..diagvariable import DiagVariable
 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 ..snrefcontext import SnRefContext
 from ..utils import dataclass_fields_asdict
 from ..variablegroup import VariableGroup
 from .diaglayerraw import DiagLayerRaw
 
 
-@dataclass
+@dataclass(kw_only=True)
 class EcuSharedDataRaw(DiagLayerRaw):
     """This is a diagnostic layer for data shared accross others
     """
 
-    diag_variables_raw: list[DiagVariable | OdxLinkRef]
-    variable_groups: NamedItemList[VariableGroup]
+    diag_variables_raw: list[DiagVariable | OdxLinkRef] = field(default_factory=list)
+    variable_groups: NamedItemList[VariableGroup] = field(default_factory=NamedItemList)
 
     @property
     def diag_variables(self) -> NamedItemList[DiagVariable]:
         return self._diag_variables
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element,
-                doc_frags: list[OdxDocFragment]) -> "EcuSharedDataRaw":
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "EcuSharedDataRaw":
         # objects contained by diagnostic layers exibit 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.
-        dlr = DiagLayerRaw.from_et(et_element, doc_frags)
+        dlr = DiagLayerRaw.from_et(et_element, context)
         kwargs = dataclass_fields_asdict(dlr)
-        doc_frags = dlr.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")
         ])
 

odxtools/diaglayers/ecuvariant.py

@@ -12,7 +12,8 @@ from ..dyndefinedspec import DynDefinedSpec
 from ..ecuvariantpattern import EcuVariantPattern
 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 HasVariableGroups, VariableGroup
 from .basevariant import BaseVariant
@@ -21,7 +22,7 @@ from .ecuvariantraw import EcuVariantRaw
 from .hierarchyelement import HierarchyElement
 
 
-@dataclass
+@dataclass(kw_only=True)
 class EcuVariant(HierarchyElement):
 
     @property
@@ -75,8 +76,8 @@ class EcuVariant(HierarchyElement):
     #######
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element, doc_frags: list[OdxDocFragment]) -> "EcuVariant":
-        ecu_variant_raw = EcuVariantRaw.from_et(et_element, doc_frags)
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "EcuVariant":
+        ecu_variant_raw = EcuVariantRaw.from_et(et_element, context)
 
         return EcuVariant(diag_layer_raw=ecu_variant_raw)
 

odxtools/diaglayers/ecuvariantraw.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 ..dyndefinedspec import DynDefinedSpec
 from ..ecuvariantpattern import EcuVariantPattern
 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,59 +17,57 @@ from ..variablegroup import VariableGroup
 from .hierarchyelementraw import HierarchyElementRaw
 
 
-@dataclass
+@dataclass(kw_only=True)
 class EcuVariantRaw(HierarchyElementRaw):
-    diag_variables_raw: list[DiagVariable | OdxLinkRef]
-    variable_groups: NamedItemList[VariableGroup]
-    ecu_variant_patterns: list[EcuVariantPattern]
-    dyn_defined_spec: DynDefinedSpec | None
-    parent_refs: list[ParentRef]
+    diag_variables_raw: list[DiagVariable | OdxLinkRef] = field(default_factory=list)
+    variable_groups: NamedItemList[VariableGroup] = field(default_factory=NamedItemList)
+    ecu_variant_patterns: list[EcuVariantPattern] = field(default_factory=list)
+    dyn_defined_spec: DynDefinedSpec | 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]) -> "EcuVariantRaw":
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "EcuVariantRaw":
         # objects contained by diagnostic layers exibit 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")
         ])
 
         ecu_variant_patterns = None
         ecu_variant_patterns = [
-            EcuVariantPattern.from_et(varpat_elem, doc_frags)
+            EcuVariantPattern.from_et(varpat_elem, context)
             for varpat_elem in et_element.iterfind("ECU-VARIANT-PATTERNS/ECU-VARIANT-PATTERN")
         ]
 
         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)
 
         parent_refs = [
-            ParentRef.from_et(pr_el, doc_frags)
+            ParentRef.from_et(pr_el, context)
             for pr_el in et_element.iterfind("PARENT-REFS/PARENT-REF")
         ]
 

odxtools/diaglayers/functionalgroup.py

@@ -10,7 +10,8 @@ from typing_extensions import override
 from ..diagvariable import DiagVariable
 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 .diaglayer import DiagLayer
@@ -18,7 +19,7 @@ from .functionalgroupraw import FunctionalGroupRaw
 from .hierarchyelement import HierarchyElement
 
 
-@dataclass
+@dataclass(kw_only=True)
 class FunctionalGroup(HierarchyElement):
     """This is a diagnostic layer for functionality shared between multiple ECU variants
     """
@@ -44,9 +45,8 @@ class FunctionalGroup(HierarchyElement):
         return self.functional_group_raw.parent_refs
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element,
-                doc_frags: list[OdxDocFragment]) -> "FunctionalGroup":
-        functional_group_raw = FunctionalGroupRaw.from_et(et_element, doc_frags)
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "FunctionalGroup":
+        functional_group_raw = FunctionalGroupRaw.from_et(et_element, context)
 
         return FunctionalGroup(diag_layer_raw=functional_group_raw)
 

odxtools/diaglayers/functionalgroupraw.py

@@ -1,12 +1,13 @@
 # SPDX-License-Identifier: MIT
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from typing import Any
 from xml.etree import ElementTree
 
 from ..diagvariable import DiagVariable
 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
@@ -14,50 +15,48 @@ from ..variablegroup import VariableGroup
 from .hierarchyelementraw import HierarchyElementRaw
 
 
-@dataclass
+@dataclass(kw_only=True)
 class FunctionalGroupRaw(HierarchyElementRaw):
     """This is a diagnostic layer for common functionality of an ECU
     """
 
-    diag_variables_raw: list[DiagVariable | OdxLinkRef]
-    variable_groups: NamedItemList[VariableGroup]
-    parent_refs: list[ParentRef]
+    diag_variables_raw: list[DiagVariable | OdxLinkRef] = field(default_factory=list)
+    variable_groups: NamedItemList[VariableGroup] = field(default_factory=NamedItemList)
+    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]) -> "FunctionalGroupRaw":
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "FunctionalGroupRaw":
         # objects contained by diagnostic layers exibit 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")
         ])
 
         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")
         ]