odxtools 6.6.1__py3-none-any.whl → 9.3.0__py3-none-any.whl

odxtools/diagdatadictionaryspec.py

@@ -1,63 +1,82 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
 from itertools import chain
-from typing import TYPE_CHECKING, Any, Dict, List, Optional
+from typing import Any, Dict, List, Optional
 from xml.etree import ElementTree
 
+from .admindata import AdminData
 from .basicstructure import BasicStructure
-from .createsdgs import create_sdgs_from_et
 from .dataobjectproperty import DataObjectProperty
 from .dopbase import DopBase
 from .dtcdop import DtcDop
+from .dynamicendmarkerfield import DynamicEndmarkerField
 from .dynamiclengthfield import DynamicLengthField
 from .endofpdufield import EndOfPduField
 from .environmentdata import EnvironmentData
 from .environmentdatadescription import EnvironmentDataDescription
 from .exceptions import odxraise
-from .globals import logger
 from .multiplexer import Multiplexer
 from .nameditemlist import NamedItemList
 from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
+from .snrefcontext import SnRefContext
 from .specialdatagroup import SpecialDataGroup
+from .staticfield import StaticField
 from .structure import Structure
 from .table import Table
 from .unitspec import UnitSpec
 
-if TYPE_CHECKING:
-    from .diaglayer import DiagLayer
-
 
 @dataclass
 class DiagDataDictionarySpec:
+    admin_data: Optional[AdminData]
     dtc_dops: NamedItemList[DtcDop]
+    env_data_descs: NamedItemList[EnvironmentDataDescription]
     data_object_props: NamedItemList[DataObjectProperty]
     structures: NamedItemList[BasicStructure]
-    end_of_pdu_fields: NamedItemList[EndOfPduField]
+    static_fields: NamedItemList[StaticField]
     dynamic_length_fields: NamedItemList[DynamicLengthField]
-    tables: NamedItemList[Table]
-    env_data_descs: NamedItemList[EnvironmentDataDescription]
-    env_datas: NamedItemList[EnvironmentData]
+    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]
 
     def __post_init__(self) -> None:
         self._all_data_object_properties: NamedItemList[DopBase] = NamedItemList(
             chain(
                 self.dtc_dops,
+                self.env_data_descs,
                 self.data_object_props,
                 self.structures,
-                self.end_of_pdu_fields,
+                self.static_fields,
                 self.dynamic_length_fields,
-                self.env_data_descs,
-                self.env_datas,
+                self.dynamic_endmarker_fields,
+                self.end_of_pdu_fields,
                 self.muxs,
+                self.env_datas,
             ))
 
     @staticmethod
     def from_et(et_element: ElementTree.Element,
                 doc_frags: List[OdxDocFragment]) -> "DiagDataDictionarySpec":
-        # Parse DOP-BASEs
+        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)
+
+        dtc_dops = []
+        for dtc_dop_elem in et_element.iterfind("DTC-DOPS/DTC-DOP"):
+            dtc_dop = DtcDop.from_et(dtc_dop_elem, doc_frags)
+            if not isinstance(dtc_dop, DtcDop):
+                odxraise()
+            dtc_dops.append(dtc_dop)
+
+        env_data_descs = [
+            EnvironmentDataDescription.from_et(env_data_desc_element, doc_frags)
+            for env_data_desc_element in et_element.iterfind("ENV-DATA-DESCS/ENV-DATA-DESC")
+        ]
+
         data_object_props = [
             DataObjectProperty.from_et(dop_element, doc_frags)
             for dop_element in et_element.iterfind("DATA-OBJECT-PROPS/DATA-OBJECT-PROP")
@@ -68,9 +87,9 @@ class DiagDataDictionarySpec:
             for structure_element in et_element.iterfind("STRUCTURES/STRUCTURE")
         ]
 
-        end_of_pdu_fields = [
-            EndOfPduField.from_et(eofp_element, doc_frags)
-            for eofp_element in et_element.iterfind("END-OF-PDU-FIELDS/END-OF-PDU-FIELD")
+        static_fields = [
+            StaticField.from_et(dl_element, doc_frags)
+            for dl_element in et_element.iterfind("STATIC-FIELDS/STATIC-FIELD")
         ]
 
         dynamic_length_fields = [
@@ -78,21 +97,19 @@ class DiagDataDictionarySpec:
             for dl_element in et_element.iterfind("DYNAMIC-LENGTH-FIELDS/DYNAMIC-LENGTH-FIELD")
         ]
 
-        dtc_dops = []
-        for dtc_dop_elem in et_element.iterfind("DTC-DOPS/DTC-DOP"):
-            dtc_dop = DtcDop.from_et(dtc_dop_elem, doc_frags)
-            if not isinstance(dtc_dop, DtcDop):
-                odxraise()
-            dtc_dops.append(dtc_dop)
+        dynamic_endmarker_fields = [
+            DynamicEndmarkerField.from_et(dl_element, doc_frags) for dl_element in
+            et_element.iterfind("DYNAMIC-ENDMARKER-FIELDS/DYNAMIC-ENDMARKER-FIELD")
+        ]
 
-        tables = [
-            Table.from_et(table_element, doc_frags)
-            for table_element in et_element.iterfind("TABLES/TABLE")
+        end_of_pdu_fields = [
+            EndOfPduField.from_et(eofp_element, doc_frags)
+            for eofp_element in et_element.iterfind("END-OF-PDU-FIELDS/END-OF-PDU-FIELD")
         ]
 
-        env_data_descs = [
-            EnvironmentDataDescription.from_et(env_data_desc_element, doc_frags)
-            for env_data_desc_element in et_element.iterfind("ENV-DATA-DESCS/ENV-DATA-DESC")
+        muxs = [
+            Multiplexer.from_et(mux_element, doc_frags)
+            for mux_element in et_element.iterfind("MUXS/MUX")
         ]
 
         env_data_elements = chain(
@@ -105,42 +122,34 @@ class DiagDataDictionarySpec:
             for env_data_element in env_data_elements
         ]
 
-        muxs = [
-            Multiplexer.from_et(mux_element, doc_frags)
-            for mux_element in et_element.iterfind("MUXS/MUX")
-        ]
-
         if (spec_elem := et_element.find("UNIT-SPEC")) is not None:
             unit_spec = UnitSpec.from_et(spec_elem, doc_frags)
         else:
             unit_spec = None
 
-        # TODO: Parse different specs.. Which of them are needed?
-        for (path, name) in [
-            ("STATIC-FIELDS", "static fields"),
-            ("DYNAMIC-LENGTH-FIELDS/DYNAMIC-LENGTH-FIELD", "dynamic length fields"),
-            (
-                "DYNAMIC-ENDMARKER-FIELDS/DYNAMIC-ENDMARKER-FIELD",
-                "dynamic endmarker fields",
-            ),
-        ]:
-            num = len(list(et_element.iterfind(path)))
-            if num > 0:
-                logger.info(f"Not implemented: Did not parse {num} {name}.")
-
-        sdgs = create_sdgs_from_et(et_element.find("SDGS"), doc_frags)
+        tables = [
+            Table.from_et(table_element, doc_frags)
+            for table_element in et_element.iterfind("TABLES/TABLE")
+        ]
+
+        sdgs = [
+            SpecialDataGroup.from_et(sdge, doc_frags) for sdge in et_element.iterfind("SDGS/SDG")
+        ]
 
         return DiagDataDictionarySpec(
+            admin_data=admin_data,
+            dtc_dops=NamedItemList(dtc_dops),
+            env_data_descs=NamedItemList(env_data_descs),
             data_object_props=NamedItemList(data_object_props),
             structures=NamedItemList(structures),
-            end_of_pdu_fields=NamedItemList(end_of_pdu_fields),
+            static_fields=NamedItemList(static_fields),
             dynamic_length_fields=NamedItemList(dynamic_length_fields),
-            dtc_dops=NamedItemList(dtc_dops),
+            dynamic_endmarker_fields=NamedItemList(dynamic_endmarker_fields),
+            end_of_pdu_fields=NamedItemList(end_of_pdu_fields),
+            muxs=NamedItemList(muxs),
+            env_datas=NamedItemList(env_datas),
             unit_spec=unit_spec,
             tables=NamedItemList(tables),
-            env_data_descs=NamedItemList(env_data_descs),
-            env_datas=NamedItemList(env_datas),
-            muxs=NamedItemList(muxs),
             sdgs=sdgs,
         )
 
@@ -148,81 +157,96 @@ class DiagDataDictionarySpec:
         # note that DataDictionarySpec objects do not exhibit an ODXLINK id.
         odxlinks = {}
 
-        for data_object_prop in self.data_object_props:
-            odxlinks.update(data_object_prop._build_odxlinks())
+        if self.admin_data is not None:
+            odxlinks.update(self.admin_data._build_odxlinks())
         for dtc_dop in self.dtc_dops:
             odxlinks.update(dtc_dop._build_odxlinks())
         for env_data_desc in self.env_data_descs:
             odxlinks.update(env_data_desc._build_odxlinks())
-        for env_data in self.env_datas:
-            odxlinks.update(env_data._build_odxlinks())
-        for mux in self.muxs:
-            odxlinks.update(mux._build_odxlinks())
-        for sdg in self.sdgs:
-            odxlinks.update(sdg._build_odxlinks())
+        for data_object_prop in self.data_object_props:
+            odxlinks.update(data_object_prop._build_odxlinks())
         for structure in self.structures:
             odxlinks.update(structure._build_odxlinks())
+        for static_field in self.static_fields:
+            odxlinks.update(static_field._build_odxlinks())
         for dynamic_length_field in self.dynamic_length_fields:
             odxlinks.update(dynamic_length_field._build_odxlinks())
+        for dynamic_endmarker_field in self.dynamic_endmarker_fields:
+            odxlinks.update(dynamic_endmarker_field._build_odxlinks())
         for end_of_pdu_field in self.end_of_pdu_fields:
             odxlinks.update(end_of_pdu_field._build_odxlinks())
-        for table in self.tables:
-            odxlinks.update(table._build_odxlinks())
-
+        for mux in self.muxs:
+            odxlinks.update(mux._build_odxlinks())
+        for env_data in self.env_datas:
+            odxlinks.update(env_data._build_odxlinks())
         if self.unit_spec is not None:
             odxlinks.update(self.unit_spec._build_odxlinks())
+        for table in self.tables:
+            odxlinks.update(table._build_odxlinks())
+        for sdg in self.sdgs:
+            odxlinks.update(sdg._build_odxlinks())
 
         return odxlinks
 
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
-        for data_object_prop in self.data_object_props:
-            data_object_prop._resolve_odxlinks(odxlinks)
+        if self.admin_data is not None:
+            self.admin_data._resolve_odxlinks(odxlinks)
         for dtc_dop in self.dtc_dops:
             dtc_dop._resolve_odxlinks(odxlinks)
+        for env_data_desc in self.env_data_descs:
+            env_data_desc._resolve_odxlinks(odxlinks)
+        for data_object_prop in self.data_object_props:
+            data_object_prop._resolve_odxlinks(odxlinks)
+        for structure in self.structures:
+            structure._resolve_odxlinks(odxlinks)
+        for static_field in self.static_fields:
+            static_field._resolve_odxlinks(odxlinks)
         for dynamic_length_field in self.dynamic_length_fields:
             dynamic_length_field._resolve_odxlinks(odxlinks)
+        for dynamic_endmarker_field in self.dynamic_endmarker_fields:
+            dynamic_endmarker_field._resolve_odxlinks(odxlinks)
         for end_of_pdu_field in self.end_of_pdu_fields:
             end_of_pdu_field._resolve_odxlinks(odxlinks)
-        for env_data_desc in self.env_data_descs:
-            env_data_desc._resolve_odxlinks(odxlinks)
-        for env_data in self.env_datas:
-            env_data._resolve_odxlinks(odxlinks)
         for mux in self.muxs:
             mux._resolve_odxlinks(odxlinks)
-        for sdg in self.sdgs:
-            sdg._resolve_odxlinks(odxlinks)
-        for structure in self.structures:
-            structure._resolve_odxlinks(odxlinks)
-        for table in self.tables:
-            table._resolve_odxlinks(odxlinks)
-
+        for env_data in self.env_datas:
+            env_data._resolve_odxlinks(odxlinks)
         if self.unit_spec is not None:
             self.unit_spec._resolve_odxlinks(odxlinks)
+        for table in self.tables:
+            table._resolve_odxlinks(odxlinks)
+        for sdg in self.sdgs:
+            sdg._resolve_odxlinks(odxlinks)
 
-    def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
-        for data_object_prop in self.data_object_props:
-            data_object_prop._resolve_snrefs(diag_layer)
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
+        if self.admin_data is not None:
+            self.admin_data._resolve_snrefs(context)
         for dtc_dop in self.dtc_dops:
-            dtc_dop._resolve_snrefs(diag_layer)
+            dtc_dop._resolve_snrefs(context)
+        for env_data_desc in self.env_data_descs:
+            env_data_desc._resolve_snrefs(context)
+        for data_object_prop in self.data_object_props:
+            data_object_prop._resolve_snrefs(context)
+        for structure in self.structures:
+            structure._resolve_snrefs(context)
+        for static_field in self.static_fields:
+            static_field._resolve_snrefs(context)
         for dynamic_length_field in self.dynamic_length_fields:
-            dynamic_length_field._resolve_snrefs(diag_layer)
+            dynamic_length_field._resolve_snrefs(context)
+        for dynamic_endmarker_field in self.dynamic_endmarker_fields:
+            dynamic_endmarker_field._resolve_snrefs(context)
         for end_of_pdu_field in self.end_of_pdu_fields:
-            end_of_pdu_field._resolve_snrefs(diag_layer)
-        for env_data_desc in self.env_data_descs:
-            env_data_desc._resolve_snrefs(diag_layer)
-        for env_data in self.env_datas:
-            env_data._resolve_snrefs(diag_layer)
+            end_of_pdu_field._resolve_snrefs(context)
         for mux in self.muxs:
-            mux._resolve_snrefs(diag_layer)
-        for sdg in self.sdgs:
-            sdg._resolve_snrefs(diag_layer)
-        for structure in self.structures:
-            structure._resolve_snrefs(diag_layer)
-        for table in self.tables:
-            table._resolve_snrefs(diag_layer)
-
+            mux._resolve_snrefs(context)
+        for env_data in self.env_datas:
+            env_data._resolve_snrefs(context)
         if self.unit_spec is not None:
-            self.unit_spec._resolve_snrefs(diag_layer)
+            self.unit_spec._resolve_snrefs(context)
+        for table in self.tables:
+            table._resolve_snrefs(context)
+        for sdg in self.sdgs:
+            sdg._resolve_snrefs(context)
 
     @property
     def all_data_object_properties(self) -> NamedItemList[DopBase]:

odxtools/diaglayercontainer.py

@@ -1,32 +1,39 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
 from itertools import chain
-from typing import Any, Dict, List, Optional, Union
+from typing import TYPE_CHECKING, Any, Dict, List, Union
 from xml.etree import ElementTree
 
-from .admindata import AdminData
-from .companydata import CompanyData
-from .createcompanydatas import create_company_datas_from_et
-from .createsdgs import create_sdgs_from_et
-from .diaglayer import DiagLayer
-from .element import IdentifiableElement
-from .exceptions import odxrequire
+from .diaglayers.basevariant import BaseVariant
+from .diaglayers.diaglayer import DiagLayer
+from .diaglayers.ecushareddata import EcuSharedData
+from .diaglayers.ecuvariant import EcuVariant
+from .diaglayers.functionalgroup import FunctionalGroup
+from .diaglayers.protocol import Protocol
 from .nameditemlist import NamedItemList
+from .odxcategory import OdxCategory
 from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
-from .specialdatagroup import SpecialDataGroup
+from .snrefcontext import SnRefContext
 from .utils import dataclass_fields_asdict
 
+if TYPE_CHECKING:
+    from .database import Database
+
 
 @dataclass
-class DiagLayerContainer(IdentifiableElement):
-    admin_data: Optional[AdminData]
-    company_datas: NamedItemList[CompanyData]
-    ecu_shared_datas: NamedItemList[DiagLayer]
-    protocols: NamedItemList[DiagLayer]
-    functional_groups: NamedItemList[DiagLayer]
-    base_variants: NamedItemList[DiagLayer]
-    ecu_variants: NamedItemList[DiagLayer]
-    sdgs: List[SpecialDataGroup]
+class DiagLayerContainer(OdxCategory):
+    ecu_shared_datas: NamedItemList[EcuSharedData]
+    protocols: NamedItemList[Protocol]
+    functional_groups: NamedItemList[FunctionalGroup]
+    base_variants: NamedItemList[BaseVariant]
+    ecu_variants: NamedItemList[EcuVariant]
+
+    @property
+    def ecus(self) -> NamedItemList[EcuVariant]:
+        """ECU variants defined in the container
+
+        This property is an alias for `.ecu_variants`"""
+        return self.ecu_variants
 
     def __post_init__(self) -> None:
         self._diag_layers = NamedItemList[DiagLayer](chain(
@@ -41,56 +48,41 @@ class DiagLayerContainer(IdentifiableElement):
     def from_et(et_element: ElementTree.Element,
                 doc_frags: List[OdxDocFragment]) -> "DiagLayerContainer":
 
-        short_name = odxrequire(et_element.findtext("SHORT-NAME"))
-        # create the current ODX "document fragment" (description of the
-        # current document for references and IDs)
-        doc_frags = [OdxDocFragment(short_name, "CONTAINER")]
-        kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, doc_frags))
+        cat = OdxCategory.category_from_et(et_element, doc_frags, doc_type="CONTAINER")
+        doc_frags = cat.odx_id.doc_fragments
+        kwargs = dataclass_fields_asdict(cat)
 
-        admin_data = AdminData.from_et(et_element.find("ADMIN-DATA"), doc_frags)
-        company_datas = create_company_datas_from_et(et_element.find("COMPANY-DATAS"), doc_frags)
         ecu_shared_datas = NamedItemList([
-            DiagLayer.from_et(dl_element, doc_frags)
+            EcuSharedData.from_et(dl_element, doc_frags)
             for dl_element in et_element.iterfind("ECU-SHARED-DATAS/ECU-SHARED-DATA")
         ])
         protocols = NamedItemList([
-            DiagLayer.from_et(dl_element, doc_frags)
+            Protocol.from_et(dl_element, doc_frags)
             for dl_element in et_element.iterfind("PROTOCOLS/PROTOCOL")
         ])
         functional_groups = NamedItemList([
-            DiagLayer.from_et(dl_element, doc_frags)
+            FunctionalGroup.from_et(dl_element, doc_frags)
             for dl_element in et_element.iterfind("FUNCTIONAL-GROUPS/FUNCTIONAL-GROUP")
         ])
         base_variants = NamedItemList([
-            DiagLayer.from_et(dl_element, doc_frags)
+            BaseVariant.from_et(dl_element, doc_frags)
             for dl_element in et_element.iterfind("BASE-VARIANTS/BASE-VARIANT")
         ])
         ecu_variants = NamedItemList([
-            DiagLayer.from_et(dl_element, doc_frags)
+            EcuVariant.from_et(dl_element, doc_frags)
             for dl_element in et_element.iterfind("ECU-VARIANTS/ECU-VARIANT")
         ])
-        sdgs = create_sdgs_from_et(et_element.find("SDGS"), doc_frags)
 
         return DiagLayerContainer(
-            admin_data=admin_data,
-            company_datas=company_datas,
             ecu_shared_datas=ecu_shared_datas,
             protocols=protocols,
             functional_groups=functional_groups,
             base_variants=base_variants,
             ecu_variants=ecu_variants,
-            sdgs=sdgs,
             **kwargs)
 
     def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
-        result = {self.odx_id: self}
-
-        if self.admin_data is not None:
-            result.update(self.admin_data._build_odxlinks())
-        for cd in self.company_datas:
-            result.update(cd._build_odxlinks())
-        for sdg in self.sdgs:
-            result.update(sdg._build_odxlinks())
+        result = super()._build_odxlinks()
 
         for ecu_shared_data in self.ecu_shared_datas:
             result.update(ecu_shared_data._build_odxlinks())
@@ -106,12 +98,7 @@ class DiagLayerContainer(IdentifiableElement):
         return result
 
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
-        if self.admin_data is not None:
-            self.admin_data._resolve_odxlinks(odxlinks)
-        for cd in self.company_datas:
-            cd._resolve_odxlinks(odxlinks)
-        for sdg in self.sdgs:
-            sdg._resolve_odxlinks(odxlinks)
+        super()._resolve_odxlinks(odxlinks)
 
         for ecu_shared_data in self.ecu_shared_datas:
             ecu_shared_data._resolve_odxlinks(odxlinks)
@@ -124,17 +111,22 @@ class DiagLayerContainer(IdentifiableElement):
         for ecu_variant in self.ecu_variants:
             ecu_variant._resolve_odxlinks(odxlinks)
 
-    def _finalize_init(self, odxlinks: OdxLinkDatabase) -> None:
+    def _finalize_init(self, database: "Database", odxlinks: OdxLinkDatabase) -> None:
+        super()._finalize_init(database, odxlinks)
+
         for ecu_shared_data in self.ecu_shared_datas:
-            ecu_shared_data._finalize_init(odxlinks)
+            ecu_shared_data._finalize_init(database, odxlinks)
         for protocol in self.protocols:
-            protocol._finalize_init(odxlinks)
+            protocol._finalize_init(database, odxlinks)
         for functional_group in self.functional_groups:
-            functional_group._finalize_init(odxlinks)
+            functional_group._finalize_init(database, odxlinks)
         for base_variant in self.base_variants:
-            base_variant._finalize_init(odxlinks)
+            base_variant._finalize_init(database, odxlinks)
         for ecu_variant in self.ecu_variants:
-            ecu_variant._finalize_init(odxlinks)
+            ecu_variant._finalize_init(database, odxlinks)
+
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
+        super()._resolve_snrefs(context)
 
     @property
     def diag_layers(self) -> NamedItemList[DiagLayer]:

odxtools/diaglayers/basevariant.py

@@ -0,0 +1,128 @@
+# SPDX-License-Identifier: MIT
+from copy import deepcopy
+from dataclasses import dataclass
+from typing import Any, Dict, Iterable, List, Optional, Union, cast
+from xml.etree import ElementTree
+
+from typing_extensions import override
+
+from ..diagvariable import DiagVariable
+from ..dyndefinedspec import DynDefinedSpec
+from ..exceptions import odxassert
+from ..nameditemlist import NamedItemList
+from ..odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkRef
+from ..parentref import ParentRef
+from ..variablegroup import VariableGroup
+from .basevariantraw import BaseVariantRaw
+from .diaglayer import DiagLayer
+from .hierarchyelement import HierarchyElement
+
+
+@dataclass
+class BaseVariant(HierarchyElement):
+    """This is a diagnostic layer for common functionality of an ECU
+    """
+
+    @property
+    def base_variant_raw(self) -> BaseVariantRaw:
+        return cast(BaseVariantRaw, self.diag_layer_raw)
+
+    #####
+    # <properties forwarded to the "raw" base variant>
+    #####
+    @property
+    def diag_variables_raw(self) -> List[Union[DiagVariable, OdxLinkRef]]:
+        return self.base_variant_raw.diag_variables_raw
+
+    @property
+    def dyn_defined_spec(self) -> Optional[DynDefinedSpec]:
+        return self.base_variant_raw.dyn_defined_spec
+
+    @property
+    def parent_refs(self) -> List[ParentRef]:
+        return self.base_variant_raw.parent_refs
+
+    #####
+    # </properties forwarded to the "raw" base variant>
+    #####
+
+    #######
+    # <properties subject to value inheritance>
+    #######
+    @property
+    def diag_variables(self) -> NamedItemList[DiagVariable]:
+        return self._diag_variables
+
+    @property
+    def variable_groups(self) -> NamedItemList[VariableGroup]:
+        return self._variable_groups
+
+    #######
+    # </properties subject to value inheritance>
+    #######
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "BaseVariant":
+        base_variant_raw = BaseVariantRaw.from_et(et_element, doc_frags)
+
+        return BaseVariant(diag_layer_raw=base_variant_raw)
+
+    def __post_init__(self) -> None:
+        super().__post_init__()
+
+        odxassert(
+            isinstance(self.diag_layer_raw, BaseVariantRaw),
+            "The raw diagnostic layer passed to BaseVariant "
+            "must be a BaseVariantRaw")
+
+    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
+        initialized, so `_finalize_init()` should to be called on it
+        before it can be used normally.
+        """
+
+        result = super().__deepcopy__(memo)
+
+        # note that the self.base_variant_raw object is *not* copied at
+        # this place because the attribute points to the same object
+        # as self.diag_layer_raw.
+        result.base_variant_raw = deepcopy(self.base_variant_raw, memo)
+
+        return result
+
+    @override
+    def _compute_value_inheritance(self, odxlinks: OdxLinkDatabase) -> None:
+        super()._compute_value_inheritance(odxlinks)
+
+        self._diag_variables = NamedItemList(self._compute_available_diag_variables(odxlinks))
+        self._variable_groups = NamedItemList(self._compute_available_variable_groups(odxlinks))
+
+    def _compute_available_diag_variables(self,
+                                          odxlinks: OdxLinkDatabase) -> Iterable[DiagVariable]:
+
+        def get_local_objects_fn(dl: DiagLayer) -> Iterable[DiagVariable]:
+            if not hasattr(dl.diag_layer_raw, "diag_variables"):
+                return []
+
+            return dl.diag_layer_raw.diag_variables  # type: ignore[no-any-return]
+
+        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)
+
+    def _compute_available_variable_groups(self,
+                                           odxlinks: OdxLinkDatabase) -> Iterable[VariableGroup]:
+
+        def get_local_objects_fn(dl: DiagLayer) -> Iterable[VariableGroup]:
+            if not hasattr(dl.diag_layer_raw, "variable_groups"):
+                return []
+
+            return dl.diag_layer_raw.variable_groups  # type: ignore[no-any-return]
+
+        def not_inherited_fn(parent_ref: ParentRef) -> List[str]:
+            return []
+
+        return self._compute_available_objects(get_local_objects_fn, not_inherited_fn)