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

odxtools/diagdatadictionaryspec.py

@@ -1,7 +1,7 @@
 # SPDX-License-Identifier: MIT
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from itertools import chain
-from typing import Any, Dict, List, Optional
+from typing import Any
 from xml.etree import ElementTree
 
 from .admindata import AdminData
@@ -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: Optional[AdminData]
-    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: Optional[UnitSpec]
-    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,
@@ -149,7 +149,7 @@ class DiagDataDictionarySpec:
                 self.env_datas,
             ))
 
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         # note that DataDictionarySpec objects do not exhibit an ODXLINK id.
         odxlinks = {}
 

odxtools/diaglayercontainer.py

@@ -1,7 +1,7 @@
 # SPDX-License-Identifier: MIT
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from itertools import chain
-from typing import TYPE_CHECKING, Any, Dict, List, Union
+from typing import TYPE_CHECKING, Any
 from xml.etree import ElementTree
 
 from .diaglayers.basevariant import BaseVariant
@@ -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,
@@ -85,7 +86,7 @@ class DiagLayerContainer(OdxCategory):
             self.ecu_variants,
         ),)
 
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         result = super()._build_odxlinks()
 
         for protocol in self.protocols:
@@ -132,5 +133,5 @@ class DiagLayerContainer(OdxCategory):
     def _resolve_snrefs(self, context: SnRefContext) -> None:
         super()._resolve_snrefs(context)
 
-    def __getitem__(self, key: Union[int, str]) -> DiagLayer:
+    def __getitem__(self, key: int | str) -> DiagLayer:
         return self.diag_layers[key]

odxtools/diaglayers/basevariant.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 ..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
@@ -19,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
     """
@@ -32,19 +34,19 @@ class BaseVariant(HierarchyElement):
     # <properties forwarded to the "raw" base variant>
     #####
     @property
-    def diag_variables_raw(self) -> List[Union[DiagVariable, OdxLinkRef]]:
+    def diag_variables_raw(self) -> list[DiagVariable | OdxLinkRef]:
         return self.base_variant_raw.diag_variables_raw
 
     @property
-    def dyn_defined_spec(self) -> Optional[DynDefinedSpec]:
+    def dyn_defined_spec(self) -> DynDefinedSpec | None:
         return self.base_variant_raw.dyn_defined_spec
 
     @property
-    def base_variant_pattern(self) -> Optional[BaseVariantPattern]:
+    def base_variant_pattern(self) -> BaseVariantPattern | None:
         return self.base_variant_raw.base_variant_pattern
 
     @property
-    def parent_refs(self) -> List[ParentRef]:
+    def parent_refs(self) -> list[ParentRef]:
         return self.base_variant_raw.parent_refs
 
     #####
@@ -67,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)
 
@@ -80,7 +82,7 @@ class BaseVariant(HierarchyElement):
             "The raw diagnostic layer passed to BaseVariant "
             "must be a BaseVariantRaw")
 
-    def __deepcopy__(self, memo: Dict[int, Any]) -> Any:
+    def __deepcopy__(self, memo: dict[int, Any]) -> Any:
         """Create a deep copy of the base variant
 
         Note that the copied diagnostic layer is not fully
@@ -113,7 +115,7 @@ class BaseVariant(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)
@@ -127,7 +129,7 @@ class BaseVariant(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)

odxtools/diaglayers/basevariantraw.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 ..basevariantpattern import BaseVariantPattern
@@ -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[Union[DiagVariable, OdxLinkRef]]
-    variable_groups: NamedItemList[VariableGroup]
-    dyn_defined_spec: Optional[DynDefinedSpec]
-    base_variant_pattern: Optional[BaseVariantPattern]
-    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[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")
         ])
 
         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")
         ]
 
@@ -81,7 +80,7 @@ class BaseVariantRaw(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/diaglayer.py

@@ -1,9 +1,10 @@
 # SPDX-License-Identifier: MIT
+from collections.abc import Callable, Iterable
 from copy import copy, deepcopy
 from dataclasses import dataclass
 from functools import cached_property
 from itertools import chain
-from typing import Any, Callable, Dict, Iterable, List, Optional, Union, cast
+from typing import Any, Union, cast
 from xml.etree import ElementTree
 
 from ..admindata import AdminData
@@ -16,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
@@ -29,10 +31,10 @@ from ..unitgroup import UnitGroup
 from .diaglayerraw import DiagLayerRaw
 from .diaglayertype import DiagLayerType
 
-PrefixTree = Dict[int, Union[List[DiagService], "PrefixTree"]]
+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.
@@ -44,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)
@@ -72,7 +74,7 @@ class DiagLayer:
         else:
             self._diag_data_dictionary_spec = self.diag_layer_raw.diag_data_dictionary_spec
 
-    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."""
         result = self.diag_layer_raw._build_odxlinks()
 
@@ -91,7 +93,7 @@ class DiagLayer:
         # reference. This mechanism can thus be seen as a kind of
         # "poor man's inheritance".
         if self.import_refs:
-            imported_links: Dict[OdxLinkId, Any] = {}
+            imported_links: dict[OdxLinkId, Any] = {}
             for import_ref in self.import_refs:
                 imported_dl = odxlinks.resolve(import_ref, DiagLayer)
 
@@ -168,7 +170,7 @@ class DiagLayer:
         """
         return get_local_objects(self)
 
-    def __deepcopy__(self, memo: Dict[int, Any]) -> Any:
+    def __deepcopy__(self, memo: dict[int, Any]) -> Any:
         """Create a deep copy of the diagnostic layer
 
         Note that the copied diagnostic layer is not fully
@@ -210,15 +212,15 @@ class DiagLayer:
         return self.diag_layer_raw.short_name
 
     @property
-    def long_name(self) -> Optional[str]:
+    def long_name(self) -> str | None:
         return self.diag_layer_raw.long_name
 
     @property
-    def description(self) -> Optional[Description]:
+    def description(self) -> Description | None:
         return self.diag_layer_raw.description
 
     @property
-    def admin_data(self) -> Optional[AdminData]:
+    def admin_data(self) -> AdminData | None:
         return self.diag_layer_raw.admin_data
 
     @property
@@ -258,7 +260,7 @@ class DiagLayer:
         return self.diag_layer_raw.global_negative_responses
 
     @property
-    def import_refs(self) -> List[OdxLinkRef]:
+    def import_refs(self) -> list[OdxLinkRef]:
         return self.diag_layer_raw.import_refs
 
     @property
@@ -270,7 +272,7 @@ class DiagLayer:
         return self.diag_layer_raw.sub_components
 
     @property
-    def sdgs(self) -> List[SpecialDataGroup]:
+    def sdgs(self) -> list[SpecialDataGroup]:
         return self.diag_layer_raw.sdgs
 
     @property
@@ -359,13 +361,13 @@ class DiagLayer:
         if sub_tree.get(-1) is None:
             sub_tree[-1] = [service]
         else:
-            cast(List[DiagService], sub_tree[-1]).append(service)
+            cast(list[DiagService], sub_tree[-1]).append(service)
 
-    def _find_services_for_uds(self, message: bytes) -> List[DiagService]:
+    def _find_services_for_uds(self, message: bytes) -> list[DiagService]:
         prefix_tree = self._prefix_tree
 
         # Find matching service(s) in prefix tree
-        possible_services: List[DiagService] = []
+        possible_services: list[DiagService] = []
         for b in message:
             if b in prefix_tree:
                 odxassert(isinstance(prefix_tree[b], dict))
@@ -373,11 +375,11 @@ class DiagLayer:
             else:
                 break
             if -1 in prefix_tree:
-                possible_services += cast(List[DiagService], prefix_tree[-1])
+                possible_services += cast(list[DiagService], prefix_tree[-1])
         return possible_services
 
-    def _decode(self, message: bytes, candidate_services: Iterable[DiagService]) -> List[Message]:
-        decoded_messages: List[Message] = []
+    def _decode(self, message: bytes, candidate_services: Iterable[DiagService]) -> list[Message]:
+        decoded_messages: list[Message] = []
 
         for service in candidate_services:
             try:
@@ -415,12 +417,12 @@ class DiagLayer:
 
         return decoded_messages
 
-    def decode(self, message: bytes) -> List[Message]:
+    def decode(self, message: bytes) -> list[Message]:
         candidate_services = self._find_services_for_uds(message)
 
         return self._decode(message, candidate_services)
 
-    def decode_response(self, response: bytes, request: bytes) -> List[Message]:
+    def decode_response(self, response: bytes, request: bytes) -> list[Message]:
         candidate_services = self._find_services_for_uds(request)
         if candidate_services is None:
             raise DecodeError(f"Couldn't find corresponding service for request {request.hex()}.")