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

odxtools/compumethods/texttablecompumethod.py

@@ -1,80 +1,140 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import List, Optional
+from typing import List, cast
+from xml.etree import ElementTree
 
-from ..exceptions import DecodeError, EncodeError, odxassert
+from ..exceptions import DecodeError, EncodeError, odxassert, odxraise, odxrequire
+from ..odxlink import OdxDocFragment
 from ..odxtypes import AtomicOdxType, DataType
-from .compumethod import CompuMethod, CompuMethodCategory
+from ..utils import dataclass_fields_asdict
+from .compumethod import CompuCategory, CompuMethod
 from .compuscale import CompuScale
 
 
 @dataclass
 class TexttableCompuMethod(CompuMethod):
+    """Text table compute methods translate numbers to human readable
+    textual descriptions.
 
-    internal_to_phys: List[CompuScale]
-    # For compu_default_value, the compu_const is always defined
-    # the compu_inverse_value is optional
-    compu_default_value: Optional[CompuScale]
+    For details, refer to ASAM specification MCD-2 D (ODX), section 7.3.6.6.7.
+
+    """
+
+    @staticmethod
+    def compu_method_from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment], *,
+                             internal_type: DataType,
+                             physical_type: DataType) -> "TexttableCompuMethod":
+        cm = CompuMethod.compu_method_from_et(
+            et_element, doc_frags, internal_type=internal_type, physical_type=physical_type)
+        kwargs = dataclass_fields_asdict(cm)
+
+        return TexttableCompuMethod(**kwargs)
 
     def __post_init__(self) -> None:
-        odxassert(self.physical_type == DataType.A_UNICODE2STRING,
-                  "TEXTTABLE must have A_UNICODE2STRING as its physical datatype.")
+        odxassert(self.category == CompuCategory.TEXTTABLE,
+                  "TexttableCompuMethod must exhibit TEXTTABLE category")
+
+        # the spec says that the physical data type shall be
+        # A_UNICODE2STRING, but we are a bit more lenient and allow
+        # any kind of string...
+        odxassert(
+            self.physical_type
+            in [DataType.A_UNICODE2STRING, DataType.A_UTF8STRING, DataType.A_ASCIISTRING],
+            "TEXTTABLE must have string type as its physical datatype.")
+
+        if self.compu_internal_to_phys is None:
+            odxraise("TEXTTABLE compu methods must exhibit a COMPU-INTERNAL-TO-PHYS subtag.")
+            scales = []
+        else:
+            scales = self.compu_internal_to_phys.compu_scales
+
         odxassert(
-            all(scale.lower_limit is not None or scale.upper_limit is not None
-                for scale in self.internal_to_phys),
-            "Text table compu method doesn't have expected format!")
+            all(scale.lower_limit is not None or scale.upper_limit is not None for scale in scales),
+            "All scales of TEXTTABLE compu methods must provide limits!")
 
-    @property
-    def category(self) -> CompuMethodCategory:
-        return "TEXTTABLE"
+        self._compu_physical_default_value = None
+        citp = odxrequire(self.compu_internal_to_phys)
+        if (cdv := citp.compu_default_value) is not None:
+            self._compu_physical_default_value = self.physical_type.from_string(odxrequire(cdv.vt))
 
-    def get_scales(self) -> List[CompuScale]:
-        scales = list(self.internal_to_phys)
-        if self.compu_default_value:
-            # Default is last, since it's a fallback
-            scales.append(self.compu_default_value)
-        return scales
+        self._compu_internal_default_value = None
+        cpti = self.compu_phys_to_internal
+        if cpti is not None and (cdv := cpti.compu_default_value) is not None:
+            self._compu_internal_default_value = self.internal_type.from_string(odxrequire(cdv.v))
 
     def convert_physical_to_internal(self, physical_value: AtomicOdxType) -> AtomicOdxType:
-        matching_scales = [x for x in self.get_scales() if x.compu_const == physical_value]
-        for scale in matching_scales:
-            if scale.compu_inverse_value is not None:
-                return scale.compu_inverse_value
-            elif scale.lower_limit is not None:
-                return scale.lower_limit.value
-            elif scale.upper_limit is not None:
-                return scale.upper_limit.value
-
-        raise EncodeError(f"Texttable compu method could not encode '{physical_value!r}'.")
-
-    def __is_internal_in_scale(self, internal_value: AtomicOdxType, scale: CompuScale) -> bool:
-        if scale == self.compu_default_value:
-            return True
-        if scale.lower_limit is not None and not scale.lower_limit.complies_to_lower(
-                internal_value):
-            return False
-        # If no UPPER-LIMIT is defined
-        # the COMPU-SCALE will be applied only for the value defined in LOWER-LIMIT
-        upper_limit = scale.upper_limit or scale.lower_limit
-        if upper_limit is not None and not upper_limit.complies_to_upper(internal_value):
-            return False
-        # value complies to the defined limits
-        return True
+        scales = []
+        if (citp := self.compu_internal_to_phys) is not None:
+            scales = citp.compu_scales
+        matching_scales = [
+            x for x in scales if x.compu_const is not None and x.compu_const.value == physical_value
+        ]
+
+        if len(matching_scales) == 0:
+            if self._compu_internal_default_value is None:
+                odxraise(f"Texttable could not encode {physical_value!r}.", EncodeError)
+                return cast(None, AtomicOdxType)
+
+            return self._compu_internal_default_value
+        elif len(matching_scales) > 1:
+            odxraise(f"Texttable could not uniquely encode {physical_value!r}.", EncodeError)
+
+        scale = matching_scales[0]
+        if scale.compu_inverse_value is not None and (civ :=
+                                                      scale.compu_inverse_value.value) is not None:
+            return civ
+        elif scale.lower_limit is not None and scale.lower_limit._value is not None:
+            return scale.lower_limit._value
+        elif scale.upper_limit is not None and scale.upper_limit._value is not None:
+            return scale.upper_limit._value
+
+        odxraise(f"Texttable compu method could not encode '{physical_value!r}'.", EncodeError)
 
     def convert_internal_to_physical(self, internal_value: AtomicOdxType) -> AtomicOdxType:
-        scale = next(
-            filter(
-                lambda scale: self.__is_internal_in_scale(internal_value, scale),
-                self.get_scales(),
-            ), None)
-        if scale is None or scale.compu_const is None:
-            raise DecodeError(
-                f"Texttable compu method could not decode {internal_value!r} to string.")
-        return scale.compu_const
+        scales = []
+        if (citp := self.compu_internal_to_phys) is not None:
+            scales = citp.compu_scales
+        matching_scales: List[CompuScale] = [x for x in scales if x.applies(internal_value)]
+
+        if len(matching_scales) == 0:
+            if self._compu_physical_default_value is None:
+                odxraise(f"Texttable could not decode {internal_value!r}.", DecodeError)
+                return cast(None, AtomicOdxType)
+
+            return self._compu_physical_default_value
+
+        if len(matching_scales) > 1:
+            odxraise(f"Texttable could not uniquely decode {internal_value!r}.", DecodeError)
+
+        scale = matching_scales[0]
+
+        if scale.compu_const is None:
+            odxraise(f"Encountered a COMPU-SCALE with no COMPU-CONST.")
+            return cast(None, AtomicOdxType)
+
+        if scale.compu_const.value is not None:
+            return scale.compu_const.value
+
+        odxraise(f"Texttable compu method could not decode '{internal_value!r}'.", EncodeError)
 
     def is_valid_physical_value(self, physical_value: AtomicOdxType) -> bool:
-        return any(x.compu_const == physical_value for x in self.get_scales())
+        if self._compu_physical_default_value is not None:
+            return True
+
+        scales = []
+        if (cpti := self.compu_internal_to_phys) is not None:
+            scales = cpti.compu_scales
+
+        return any(scale.compu_const.value == physical_value
+                   for scale in scales
+                   if scale.compu_const is not None)
 
     def is_valid_internal_value(self, internal_value: AtomicOdxType) -> bool:
-        return any(
-            self.__is_internal_in_scale(internal_value, scale) for scale in self.get_scales())
+        if self._compu_internal_default_value is not None:
+            return True
+
+        scales = []
+        if (citp := self.compu_internal_to_phys) is not None:
+            scales = citp.compu_scales
+
+        return any(scale.applies(internal_value) for scale in scales)

odxtools/createanydiagcodedtype.py

@@ -1,85 +1,28 @@
 # SPDX-License-Identifier: MIT
-from typing import List, cast
+from typing import List
 from xml.etree import ElementTree
 
 from .diagcodedtype import DiagCodedType
-from .exceptions import odxraise, odxrequire
+from .exceptions import odxraise
 from .globals import xsi
 from .leadinglengthinfotype import LeadingLengthInfoType
 from .minmaxlengthtype import MinMaxLengthType
-from .odxlink import OdxDocFragment, OdxLinkRef
-from .odxtypes import DataType, odxstr_to_bool
+from .odxlink import OdxDocFragment
 from .paramlengthinfotype import ParamLengthInfoType
 from .standardlengthtype import StandardLengthType
 
 
 def create_any_diag_coded_type_from_et(et_element: ElementTree.Element,
                                        doc_frags: List[OdxDocFragment]) -> DiagCodedType:
-    base_type_encoding = et_element.get("BASE-TYPE-ENCODING")
-
-    base_data_type_str = odxrequire(et_element.get("BASE-DATA-TYPE"))
-    try:
-        base_data_type = DataType(base_data_type_str)
-    except ValueError:
-        base_data_type = cast(DataType, None)
-        odxraise(f"Unknown base data type {base_data_type_str}")
-
-    is_highlow_byte_order_raw = odxstr_to_bool(et_element.get("IS-HIGHLOW-BYTE-ORDER"))
-
     dct_type = et_element.get(f"{xsi}type")
-    bit_length = None
     if dct_type == "LEADING-LENGTH-INFO-TYPE":
-        bit_length = int(odxrequire(et_element.findtext("BIT-LENGTH")))
-        return LeadingLengthInfoType(
-            base_data_type=base_data_type,
-            bit_length=bit_length,
-            base_type_encoding=base_type_encoding,
-            is_highlow_byte_order_raw=is_highlow_byte_order_raw,
-        )
+        return LeadingLengthInfoType.from_et(et_element, doc_frags)
     elif dct_type == "MIN-MAX-LENGTH-TYPE":
-        min_length = int(odxrequire(et_element.findtext("MIN-LENGTH")))
-        max_length = None
-        if et_element.find("MAX-LENGTH") is not None:
-            max_length = int(odxrequire(et_element.findtext("MAX-LENGTH")))
-        termination = odxrequire(et_element.get("TERMINATION"))
-
-        return MinMaxLengthType(
-            base_data_type=base_data_type,
-            min_length=min_length,
-            max_length=max_length,
-            termination=termination,
-            base_type_encoding=base_type_encoding,
-            is_highlow_byte_order_raw=is_highlow_byte_order_raw,
-        )
+        return MinMaxLengthType.from_et(et_element, doc_frags)
     elif dct_type == "PARAM-LENGTH-INFO-TYPE":
-        length_key_ref = odxrequire(
-            OdxLinkRef.from_et(et_element.find("LENGTH-KEY-REF"), doc_frags))
-
-        return ParamLengthInfoType(
-            base_data_type=base_data_type,
-            length_key_ref=length_key_ref,
-            base_type_encoding=base_type_encoding,
-            is_highlow_byte_order_raw=is_highlow_byte_order_raw,
-        )
+        return ParamLengthInfoType.from_et(et_element, doc_frags)
     elif dct_type == "STANDARD-LENGTH-TYPE":
-        bit_length = int(odxrequire(et_element.findtext("BIT-LENGTH")))
-        bit_mask = None
-        if (bit_mask_str := et_element.findtext("BIT-MASK")) is not None:
-            # The XSD uses the type xsd:hexBinary
-            # xsd:hexBinary allows for leading/trailing whitespace, empty strings, and it only allows an even
-            # number of hex digits, while some of the examples shown in the  ODX specification exhibit an
-            # odd number of hex digits.
-            # This causes a validation paradox, so we try to be flexible
-            bit_mask_str = bit_mask_str.strip()
-            if len(bit_mask_str):
-                bit_mask = int(bit_mask_str, 16)
-        is_condensed_raw = odxstr_to_bool(et_element.get("CONDENSED"))
-        return StandardLengthType(
-            base_data_type=base_data_type,
-            bit_length=bit_length,
-            bit_mask=bit_mask,
-            is_condensed_raw=is_condensed_raw,
-            base_type_encoding=base_type_encoding,
-            is_highlow_byte_order_raw=is_highlow_byte_order_raw,
-        )
-    raise NotImplementedError(f"I do not know the diag-coded-type {dct_type}")
+        return StandardLengthType.from_et(et_element, doc_frags)
+
+    odxraise(f"Unknown DIAG-CODED-TYPE {dct_type}", NotImplementedError)
+    return DiagCodedType.from_et(et_element, doc_frags)

odxtools/database.py

@@ -1,7 +1,8 @@
 # SPDX-License-Identifier: MIT
 from itertools import chain
+from os import PathLike
 from pathlib import Path
-from typing import List, Optional
+from typing import IO, Any, Dict, List, Optional, OrderedDict, Union
 from xml.etree import ElementTree
 from zipfile import ZipFile
 
@@ -9,11 +10,17 @@ from packaging.version import Version
 
 from .comparamspec import ComparamSpec
 from .comparamsubset import ComparamSubset
-from .diaglayer import DiagLayer
 from .diaglayercontainer import DiagLayerContainer
-from .exceptions import odxraise
+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 .exceptions import odxraise, odxrequire
 from .nameditemlist import NamedItemList
-from .odxlink import OdxLinkDatabase
+from .odxlink import OdxLinkDatabase, OdxLinkId
+from .snrefcontext import SnRefContext
 
 
 class Database:
@@ -22,110 +29,150 @@ class Database:
     into a single PDX file.
     """
 
-    def __init__(self,
-                 *,
-                 pdx_zip: Optional[ZipFile] = None,
-                 odx_d_file_name: Optional[str] = None) -> None:
-        self.model_version = None
-
-        if pdx_zip is None and odx_d_file_name is None:
-            # create an empty database object
-            self._diag_layer_containers = NamedItemList[DiagLayerContainer]()
-            self._comparam_subsets = NamedItemList[ComparamSubset]()
-            self._comparam_specs = NamedItemList[ComparamSpec]()
-            return
-
-        if pdx_zip is not None and odx_d_file_name is not None:
-            raise TypeError("The 'pdx_zip' and 'odx_d_file_name' parameters are mutually exclusive")
-
-        documents: List[ElementTree.Element] = []
-        if pdx_zip is not None:
-            names = list(pdx_zip.namelist())
-            names.sort()
-            for zip_member in names:
-                # The name of ODX files can end with .odx, .odx-d,
-                # .odx-c, .odx-cs, .odx-e, .odx-f, .odx-fd, .odx-m,
-                # .odx-v .  We could test for all that, or just make
-                # sure that the file's suffix starts with .odx
-                if Path(zip_member).suffix.startswith(".odx"):
-                    d = pdx_zip.read(zip_member)
-                    root = ElementTree.fromstring(d)
-                    documents.append(root)
-
-        elif odx_d_file_name is not None:
-            documents.append(ElementTree.parse(odx_d_file_name).getroot())
+    def __init__(self) -> None:
+        self.model_version: Optional[Version] = None
+        self.auxiliary_files: OrderedDict[str, IO[bytes]] = OrderedDict()
 
+        # create an empty database object
+        self._diag_layer_containers = NamedItemList[DiagLayerContainer]()
+        self._comparam_subsets = NamedItemList[ComparamSubset]()
+        self._comparam_specs = NamedItemList[ComparamSpec]()
+        self._short_name = "odx_database"
+
+    def add_pdx_file(self, pdx_file: Union[str, "PathLike[Any]", IO[bytes], ZipFile]) -> None:
+        """Add PDX file to database.
+        Either pass the path to the file, an IO with the file content or a ZipFile object.
+        """
+        if isinstance(pdx_file, ZipFile):
+            pdx_zip = pdx_file
+        else:
+            pdx_zip = ZipFile(pdx_file)
+        for zip_member in pdx_zip.namelist():
+            # The name of ODX files can end with .odx, .odx-d,
+            # .odx-c, .odx-cs, .odx-e, .odx-f, .odx-fd, .odx-m,
+            # .odx-v .  We could test for all that, or just make
+            # sure that the file's suffix starts with .odx
+            p = Path(zip_member)
+            if p.suffix.lower().startswith(".odx"):
+                root = ElementTree.parse(pdx_zip.open(zip_member)).getroot()
+                self._process_xml_tree(root)
+            elif p.name.lower() == "index.xml":
+                root = ElementTree.parse(pdx_zip.open(zip_member)).getroot()
+                db_short_name = odxrequire(root.findtext("SHORT-NAME"))
+                self.short_name = db_short_name
+            else:
+                self.add_auxiliary_file(zip_member, pdx_zip.open(zip_member))
+
+    def add_odx_file(self, odx_file_name: Union[str, "PathLike[Any]"]) -> None:
+        self._process_xml_tree(ElementTree.parse(odx_file_name).getroot())
+
+    def add_auxiliary_file(self,
+                           aux_file_name: Union[str, "PathLike[Any]"],
+                           aux_file_obj: Optional[IO[bytes]] = None) -> None:
+        if aux_file_obj is None:
+            aux_file_obj = open(aux_file_name, "rb")
+
+        self.auxiliary_files[str(aux_file_name)] = aux_file_obj
+
+    def _process_xml_tree(self, root: ElementTree.Element) -> None:
         dlcs: List[DiagLayerContainer] = []
         comparam_subsets: List[ComparamSubset] = []
         comparam_specs: List[ComparamSpec] = []
-        for root in documents:
-            # ODX spec version
-            model_version = Version(root.attrib.get("MODEL-VERSION", "2.0"))
-            if self.model_version is not None and self.model_version != model_version:
-                odxraise(f"Different ODX versions used in the same file (ODX {model_version} "
-                         f"and ODX {self.model_version}")
-            self.model_version = model_version
-            dlc = root.find("DIAG-LAYER-CONTAINER")
-            if dlc is not None:
-                dlcs.append(DiagLayerContainer.from_et(dlc, []))
-
-            # In ODX 2.0 there was only COMPARAM-SPEC. In ODX 2.2 the
-            # content of COMPARAM-SPEC was moved to COMPARAM-SUBSET
-            # and COMPARAM-SPEC became a container for PROT-STACKS and
-            # a PROT-STACK references a list of COMPARAM-SUBSET
-            cp_subset = root.find("COMPARAM-SUBSET")
-            if cp_subset is not None:
-                comparam_subsets.append(ComparamSubset.from_et(cp_subset, []))
-
-            cp_spec = root.find("COMPARAM-SPEC")
-            if cp_spec is not None:
-                if model_version < Version("2.2"):
-                    comparam_subsets.append(ComparamSubset.from_et(cp_spec, []))
-                else:  # odx >= 2.2
-                    comparam_specs.append(ComparamSpec.from_et(cp_spec, []))
-
-        self._diag_layer_containers = NamedItemList(dlcs)
-        self._comparam_subsets = NamedItemList(comparam_subsets)
-        self._comparam_specs = NamedItemList(comparam_specs)
-
-        self.refresh()
+
+        # ODX spec version
+        model_version = Version(root.attrib.get("MODEL-VERSION", "2.0"))
+        if self.model_version is not None and self.model_version != model_version:
+            odxraise(f"Different ODX versions used for the same database (ODX {model_version} "
+                     f"and ODX {self.model_version}")
+
+        self.model_version = model_version
+
+        dlc = root.find("DIAG-LAYER-CONTAINER")
+        if dlc is not None:
+            dlcs.append(DiagLayerContainer.from_et(dlc, []))
+
+        # In ODX 2.0 there was only COMPARAM-SPEC. In ODX 2.2 the
+        # content of COMPARAM-SPEC was moved to COMPARAM-SUBSET
+        # and COMPARAM-SPEC became a container for PROT-STACKS and
+        # a PROT-STACK references a list of COMPARAM-SUBSET
+        cp_subset = root.find("COMPARAM-SUBSET")
+        if cp_subset is not None:
+            comparam_subsets.append(ComparamSubset.from_et(cp_subset, []))
+
+        cp_spec = root.find("COMPARAM-SPEC")
+        if cp_spec is not None:
+            if model_version < Version("2.2"):
+                comparam_subsets.append(ComparamSubset.from_et(cp_spec, []))
+            else:  # odx >= 2.2
+                comparam_specs.append(ComparamSpec.from_et(cp_spec, []))
+
+        self._diag_layer_containers.extend(dlcs)
+        self._comparam_subsets.extend(comparam_subsets)
+        self._comparam_specs.extend(comparam_specs)
 
     def refresh(self) -> None:
         # Create wrapper objects
         self._diag_layers = NamedItemList(
             chain(*[dlc.diag_layers for dlc in self.diag_layer_containers]))
 
+        self._ecu_shared_datas = NamedItemList(
+            chain(*[dlc.ecu_shared_datas for dlc in self.diag_layer_containers]))
         self._protocols = NamedItemList(
             chain(*[dlc.protocols for dlc in self.diag_layer_containers]))
-
-        self._ecus = NamedItemList(chain(*[dlc.ecu_variants for dlc in self.diag_layer_containers]))
+        self._functional_groups = NamedItemList(
+            chain(*[dlc.functional_groups for dlc in self.diag_layer_containers]))
+        self._base_variants = NamedItemList(
+            chain(*[dlc.base_variants for dlc in self.diag_layer_containers]))
+        self._ecu_variants = NamedItemList(
+            chain(*[dlc.ecu_variants for dlc in self.diag_layer_containers]))
 
         # Build odxlinks
         self._odxlinks = OdxLinkDatabase()
+        self._odxlinks.update(self._build_odxlinks())
 
+        # Resolve ODXLINK references
         for subset in self.comparam_subsets:
-            self._odxlinks.update(subset._build_odxlinks())
+            subset._resolve_odxlinks(self._odxlinks)
 
         for spec in self.comparam_specs:
-            self._odxlinks.update(spec._build_odxlinks())
+            spec._resolve_odxlinks(self._odxlinks)
 
         for dlc in self.diag_layer_containers:
-            self._odxlinks.update(dlc._build_odxlinks())
+            dlc._resolve_odxlinks(self._odxlinks)
 
-        # Resolve ODXLINK references
-        for subset in self.comparam_subsets:
-            subset._resolve_odxlinks(self._odxlinks)
+        # resolve short name references for containers which do not do
+        # inheritance (we can call directly call _resolve_snrefs())
+        context = SnRefContext()
+        context.database = self
 
+        # let the diaglayers sort out the inherited objects
+        for subset in self.comparam_subsets:
+            subset._finalize_init(self, self._odxlinks)
         for spec in self.comparam_specs:
-            spec._resolve_odxlinks(self._odxlinks)
+            spec._finalize_init(self, self._odxlinks)
+        for dlc in self.diag_layer_containers:
+            dlc._finalize_init(self, self._odxlinks)
 
+        for subset in self.comparam_subsets:
+            subset._resolve_snrefs(context)
+        for spec in self.comparam_specs:
+            spec._resolve_snrefs(context)
         for dlc in self.diag_layer_containers:
-            dlc._resolve_odxlinks(self._odxlinks)
+            dlc._resolve_snrefs(context)
+
+    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+        result: Dict[OdxLinkId, Any] = {}
+
+        for subset in self.comparam_subsets:
+            result.update(subset._build_odxlinks())
+
+        for spec in self.comparam_specs:
+            result.update(spec._build_odxlinks())
 
-        # let the diaglayers sort out the inherited objects and the
-        # short name references
         for dlc in self.diag_layer_containers:
-            dlc._finalize_init(self._odxlinks)
+            result.update(dlc._build_odxlinks())
+
+        return result
 
     @property
     def odxlinks(self) -> OdxLinkDatabase:
@@ -133,19 +180,52 @@ class Database:
         return self._odxlinks
 
     @property
-    def protocols(self) -> NamedItemList[DiagLayer]:
-        """
-        All protocols defined by this database
+    def short_name(self) -> str:
+        return self._short_name
+
+    @short_name.setter
+    def short_name(self, value: str) -> None:
+        self._short_name = value
+
+    @property
+    def ecu_shared_datas(self) -> NamedItemList[EcuSharedData]:
+        """All ECU shared data layers defined by this database
+
+        ECU shared data layers act as a kind of shared library for
+        data that is common to multiple otherwise unrelated ECUs.
+
         """
+        return self._ecu_shared_datas
+
+    @property
+    def protocols(self) -> NamedItemList[Protocol]:
+        """All protocol layers defined by this database"""
         return self._protocols
 
     @property
-    def ecus(self) -> NamedItemList[DiagLayer]:
-        """ECU-variants defined in the database"""
-        return self._ecus
+    def functional_groups(self) -> NamedItemList["FunctionalGroup"]:
+        """Functional group layers defined in the database"""
+        return self._functional_groups
+
+    @property
+    def base_variants(self) -> NamedItemList["BaseVariant"]:
+        """Base variants defined in the database"""
+        return self._base_variants
+
+    @property
+    def ecus(self) -> NamedItemList["EcuVariant"]:
+        """ECU variants defined in the database
+
+        This property is an alias for `.ecu_variants`"""
+        return self._ecu_variants
+
+    @property
+    def ecu_variants(self) -> NamedItemList["EcuVariant"]:
+        """ECU variants defined in the database"""
+        return self._ecu_variants
 
     @property
-    def diag_layers(self) -> NamedItemList[DiagLayer]:
+    def diag_layers(self) -> NamedItemList["DiagLayer"]:
         """All diagnostic layers defined in the database"""
         return self._diag_layers