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

odxtools/diaglayers/diaglayerraw.py

@@ -1,7 +1,6 @@
 # SPDX-License-Identifier: MIT
-from copy import copy
-from dataclasses import dataclass
-from typing import Any, Dict, List, Optional, Union, cast
+from dataclasses import dataclass, field
+from typing import Any, cast
 from xml.etree import ElementTree
 
 from ..additionalaudience import AdditionalAudience
@@ -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: Optional[AdminData]
-    company_datas: NamedItemList[CompanyData]
-    functional_classes: NamedItemList[FunctionalClass]
-    diag_data_dictionary_spec: Optional[DiagDataDictionarySpec]
-    diag_comms_raw: List[Union[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[Union[OdxLinkRef, DiagComm]] = []
+        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: Union[OdxLinkRef, DiagComm]
+                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(
@@ -183,7 +174,7 @@ class DiagLayerRaw(IdentifiableElement):
             sdgs=sdgs,
             **kwargs)
 
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         """Construct a mapping from IDs to all objects that are contained in this diagnostic layer."""
         odxlinks = {self.odx_id: self}
 

odxtools/diaglayers/diaglayertype.py

@@ -1,6 +1,5 @@
 # SPDX-License-Identifier: MIT
 from enum import Enum
-from typing import Dict
 
 
 class DiagLayerType(Enum):
@@ -19,7 +18,7 @@ class DiagLayerType(Enum):
 
         """
 
-        PRIORITY_OF_DIAG_LAYER_TYPE: Dict[DiagLayerType, int] = {
+        PRIORITY_OF_DIAG_LAYER_TYPE: dict[DiagLayerType, int] = {
             DiagLayerType.PROTOCOL:
                 1,
             DiagLayerType.FUNCTIONAL_GROUP:

odxtools/diaglayers/ecushareddata.py

@@ -1,23 +1,24 @@
 # SPDX-License-Identifier: MIT
 from copy import deepcopy
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Dict, List, Union, cast
+from typing import TYPE_CHECKING, Any, cast
 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
     """
@@ -27,7 +28,7 @@ class EcuSharedData(DiagLayer):
         return cast(EcuSharedDataRaw, self.diag_layer_raw)
 
     @property
-    def diag_variables_raw(self) -> List[Union[OdxLinkRef, DiagVariable]]:
+    def diag_variables_raw(self) -> list[OdxLinkRef | DiagVariable]:
         return self.ecu_shared_data_raw.diag_variables_raw
 
     @property
@@ -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)
 
@@ -78,7 +78,7 @@ class EcuSharedData(DiagLayer):
         self._resolve_snrefs(context)
         context.diag_layer = None
 
-    def __deepcopy__(self, memo: Dict[int, Any]) -> Any:
+    def __deepcopy__(self, memo: dict[int, Any]) -> Any:
         """Create a deep copy of the protocol layer
 
         Note that the copied diagnostic layer is not fully

odxtools/diaglayers/ecushareddataraw.py

@@ -1,56 +1,55 @@
 # SPDX-License-Identifier: MIT
-from dataclasses import dataclass
-from typing import Any, Dict, List, Union
+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[Union[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[Union[DiagVariable, OdxLinkRef]] = []
+        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: Union[OdxLinkRef, DiagVariable]
+                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")
         ])
 
@@ -58,7 +57,7 @@ class EcuSharedDataRaw(DiagLayerRaw):
         return EcuSharedDataRaw(
             diag_variables_raw=diag_variables_raw, variable_groups=variable_groups, **kwargs)
 
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         result = super()._build_odxlinks()
         for dv_proxy in self.diag_variables_raw:
             if not isinstance(dv_proxy, OdxLinkRef):

odxtools/diaglayers/ecuvariant.py

@@ -1,7 +1,8 @@
 # SPDX-License-Identifier: MIT
+from collections.abc import Iterable
 from copy import deepcopy
 from dataclasses import dataclass
-from typing import Any, Dict, Iterable, List, Optional, Union, cast
+from typing import Any, cast
 from xml.etree import ElementTree
 
 from typing_extensions import override
@@ -11,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
@@ -20,7 +22,7 @@ from .ecuvariantraw import EcuVariantRaw
 from .hierarchyelement import HierarchyElement
 
 
-@dataclass
+@dataclass(kw_only=True)
 class EcuVariant(HierarchyElement):
 
     @property
@@ -28,19 +30,19 @@ class EcuVariant(HierarchyElement):
         return cast(EcuVariantRaw, self.diag_layer_raw)
 
     @property
-    def diag_variables_raw(self) -> List[Union[DiagVariable, OdxLinkRef]]:
+    def diag_variables_raw(self) -> list[DiagVariable | OdxLinkRef]:
         return self.ecu_variant_raw.diag_variables_raw
 
     @property
-    def dyn_defined_spec(self) -> Optional[DynDefinedSpec]:
+    def dyn_defined_spec(self) -> DynDefinedSpec | None:
         return self.ecu_variant_raw.dyn_defined_spec
 
     @property
-    def parent_refs(self) -> List[ParentRef]:
+    def parent_refs(self) -> list[ParentRef]:
         return self.ecu_variant_raw.parent_refs
 
     @property
-    def base_variant(self) -> Optional[BaseVariant]:
+    def base_variant(self) -> BaseVariant | None:
         """Return the base variant for the ECU variant
 
         The ODX specification allows at a single base variant for each
@@ -55,7 +57,7 @@ class EcuVariant(HierarchyElement):
         return None
 
     @property
-    def ecu_variant_patterns(self) -> List[EcuVariantPattern]:
+    def ecu_variant_patterns(self) -> list[EcuVariantPattern]:
         return self.ecu_variant_raw.ecu_variant_patterns
 
     #######
@@ -74,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)
 
@@ -87,7 +89,7 @@ class EcuVariant(HierarchyElement):
             "The raw diagnostic layer passed to EcuVariant "
             "must be a EcuVariantRaw")
 
-    def __deepcopy__(self, memo: Dict[int, Any]) -> Any:
+    def __deepcopy__(self, memo: dict[int, Any]) -> Any:
         """Create a deep copy of the ECU variant
 
         Note that the copied diagnostic layer is not fully
@@ -120,7 +122,7 @@ class EcuVariant(HierarchyElement):
 
             return dl.diag_layer_raw.diag_variables
 
-        def not_inherited_fn(parent_ref: ParentRef) -> List[str]:
+        def not_inherited_fn(parent_ref: ParentRef) -> list[str]:
             return parent_ref.not_inherited_variables
 
         return self._compute_available_objects(get_local_objects_fn, not_inherited_fn)
@@ -134,7 +136,7 @@ class EcuVariant(HierarchyElement):
 
             return dl.diag_layer_raw.variable_groups
 
-        def not_inherited_fn(parent_ref: ParentRef) -> List[str]:
+        def not_inherited_fn(parent_ref: ParentRef) -> list[str]:
             return []
 
         return self._compute_available_objects(get_local_objects_fn, not_inherited_fn)

odxtools/diaglayers/ecuvariantraw.py

@@ -1,6 +1,6 @@
 # SPDX-License-Identifier: MIT
-from dataclasses import dataclass
-from typing import Any, Dict, List, Optional, Union
+from dataclasses import dataclass, field
+from typing import Any
 from xml.etree import ElementTree
 
 from ..diagvariable import DiagVariable
@@ -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[Union[DiagVariable, OdxLinkRef]]
-    variable_groups: NamedItemList[VariableGroup]
-    ecu_variant_patterns: List[EcuVariantPattern]
-    dyn_defined_spec: Optional[DynDefinedSpec]
-    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[Union[DiagVariable, OdxLinkRef]] = []
+        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: Union[OdxLinkRef, DiagVariable]
+                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")
         ]
 
@@ -81,7 +80,7 @@ class EcuVariantRaw(HierarchyElementRaw):
             parent_refs=parent_refs,
             **kwargs)
 
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         result = super()._build_odxlinks()
 
         for dv_proxy in self.diag_variables_raw:

odxtools/diaglayers/functionalgroup.py

@@ -1,7 +1,8 @@
 # SPDX-License-Identifier: MIT
+from collections.abc import Iterable
 from copy import deepcopy
 from dataclasses import dataclass
-from typing import Any, Dict, Iterable, List, Union, cast
+from typing import Any, cast
 from xml.etree import ElementTree
 
 from typing_extensions import override
@@ -9,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
@@ -17,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
     """
@@ -27,7 +29,7 @@ class FunctionalGroup(HierarchyElement):
         return cast(FunctionalGroupRaw, self.diag_layer_raw)
 
     @property
-    def diag_variables_raw(self) -> List[Union[DiagVariable, OdxLinkRef]]:
+    def diag_variables_raw(self) -> list[DiagVariable | OdxLinkRef]:
         return self.functional_group_raw.diag_variables_raw
 
     @property
@@ -39,13 +41,12 @@ class FunctionalGroup(HierarchyElement):
         return self._variable_groups
 
     @property
-    def parent_refs(self) -> List[ParentRef]:
+    def parent_refs(self) -> list[ParentRef]:
         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)
 
@@ -73,7 +74,7 @@ class FunctionalGroup(HierarchyElement):
 
             return dl.diag_layer_raw.diag_variables  # type: ignore[no-any-return]
 
-        def not_inherited_fn(parent_ref: ParentRef) -> List[str]:
+        def not_inherited_fn(parent_ref: ParentRef) -> list[str]:
             return parent_ref.not_inherited_variables
 
         return self._compute_available_objects(get_local_objects_fn, not_inherited_fn)
@@ -87,12 +88,12 @@ class FunctionalGroup(HierarchyElement):
 
             return dl.diag_layer_raw.variable_groups  # type: ignore[no-any-return]
 
-        def not_inherited_fn(parent_ref: ParentRef) -> List[str]:
+        def not_inherited_fn(parent_ref: ParentRef) -> list[str]:
             return []
 
         return self._compute_available_objects(get_local_objects_fn, not_inherited_fn)
 
-    def __deepcopy__(self, memo: Dict[int, Any]) -> Any:
+    def __deepcopy__(self, memo: dict[int, Any]) -> Any:
         """Create a deep copy of the functional group layer
 
         Note that the copied diagnostic layer is not fully