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

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)

odxtools/diaglayers/basevariantraw.py

@@ -0,0 +1,123 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass
+from typing import Any, Dict, List, Optional, Union
+from xml.etree import ElementTree
+
+from ..diagvariable import DiagVariable
+from ..dyndefinedspec import DynDefinedSpec
+from ..exceptions import odxraise
+from ..nameditemlist import NamedItemList
+from ..odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef
+from ..parentref import ParentRef
+from ..snrefcontext import SnRefContext
+from ..utils import dataclass_fields_asdict
+from ..variablegroup import VariableGroup
+from .hierarchyelementraw import HierarchyElementRaw
+
+
+@dataclass
+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]
+    # TODO: base_variant_pattern: Optional[BaseVariantPattern]
+    parent_refs: List[ParentRef]
+
+    @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
+        # 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)
+        kwargs = dataclass_fields_asdict(her)
+        doc_frags = her.odx_id.doc_fragments
+
+        diag_variables_raw: List[Union[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]
+                if dv_proxy_elem.tag == "DIAG-VARIABLE-REF":
+                    dv_proxy = OdxLinkRef.from_et(dv_proxy_elem, doc_frags)
+                elif dv_proxy_elem.tag == "DIAG-VARIABLE":
+                    dv_proxy = DiagVariable.from_et(dv_proxy_elem, doc_frags)
+                else:
+                    odxraise()
+
+                diag_variables_raw.append(dv_proxy)
+
+        variable_groups = NamedItemList([
+            VariableGroup.from_et(vg_elem, doc_frags)
+            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)
+
+        parent_refs = [
+            ParentRef.from_et(pr_elem, doc_frags)
+            for pr_elem in et_element.iterfind("PARENT-REFS/PARENT-REF")
+        ]
+
+        return BaseVariantRaw(
+            diag_variables_raw=diag_variables_raw,
+            variable_groups=variable_groups,
+            dyn_defined_spec=dyn_defined_spec,
+            parent_refs=parent_refs,
+            **kwargs)
+
+    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):
+                result.update(dv_proxy._build_odxlinks())
+
+        if self.dyn_defined_spec is not None:
+            result.update(self.dyn_defined_spec._build_odxlinks())
+
+        for parent_ref in self.parent_refs:
+            result.update(parent_ref._build_odxlinks())
+
+        return result
+
+    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
+        super()._resolve_odxlinks(odxlinks)
+
+        self._diag_variables: NamedItemList[DiagVariable] = NamedItemList()
+        for dv_proxy in self.diag_variables_raw:
+            if isinstance(dv_proxy, OdxLinkRef):
+                dv = odxlinks.resolve(dv_proxy, DiagVariable)
+            else:
+                dv_proxy._resolve_odxlinks(odxlinks)
+                dv = dv_proxy
+
+            self._diag_variables.append(dv)
+
+        if self.dyn_defined_spec is not None:
+            self.dyn_defined_spec._resolve_odxlinks(odxlinks)
+
+        for parent_ref in self.parent_refs:
+            parent_ref._resolve_odxlinks(odxlinks)
+
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
+        super()._resolve_snrefs(context)
+
+        for dv_proxy in self.diag_variables_raw:
+            if not isinstance(dv_proxy, OdxLinkRef):
+                dv_proxy._resolve_snrefs(context)
+
+        if self.dyn_defined_spec is not None:
+            self.dyn_defined_spec._resolve_snrefs(context)
+
+        for parent_ref in self.parent_refs:
+            parent_ref._resolve_snrefs(context)