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

odxtools/diaglayers/ecuvariant.py

@@ -0,0 +1,124 @@
+# 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, HasDiagVariables
+from ..dyndefinedspec import DynDefinedSpec
+from ..ecuvariantpattern import EcuVariantPattern
+from ..exceptions import odxassert
+from ..nameditemlist import NamedItemList
+from ..odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkRef
+from ..parentref import ParentRef
+from ..variablegroup import HasVariableGroups, VariableGroup
+from .diaglayer import DiagLayer
+from .ecuvariantraw import EcuVariantRaw
+from .hierarchyelement import HierarchyElement
+
+
+@dataclass
+class EcuVariant(HierarchyElement):
+
+    @property
+    def ecu_variant_raw(self) -> EcuVariantRaw:
+        return cast(EcuVariantRaw, self.diag_layer_raw)
+
+    @property
+    def diag_variables_raw(self) -> List[Union[DiagVariable, OdxLinkRef]]:
+        return self.ecu_variant_raw.diag_variables_raw
+
+    @property
+    def dyn_defined_spec(self) -> Optional[DynDefinedSpec]:
+        return self.ecu_variant_raw.dyn_defined_spec
+
+    @property
+    def parent_refs(self) -> List[ParentRef]:
+        return self.ecu_variant_raw.parent_refs
+
+    @property
+    def ecu_variant_patterns(self) -> List[EcuVariantPattern]:
+        return self.ecu_variant_raw.ecu_variant_patterns
+
+    #######
+    # <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]) -> "EcuVariant":
+        ecu_variant_raw = EcuVariantRaw.from_et(et_element, doc_frags)
+
+        return EcuVariant(diag_layer_raw=ecu_variant_raw)
+
+    def __post_init__(self) -> None:
+        super().__post_init__()
+
+        odxassert(
+            isinstance(self.diag_layer_raw, EcuVariantRaw),
+            "The raw diagnostic layer passed to EcuVariant "
+            "must be a EcuVariantRaw")
+
+    def __deepcopy__(self, memo: Dict[int, Any]) -> Any:
+        """Create a deep copy of the ECU variant
+
+        Note that the copied diagnostic layer is not fully
+        initialized, so `_finalize_init()` should to be called on it
+        before it can be used normally.
+        """
+
+        result = super().__deepcopy__(memo)
+
+        # note that the self.ecu_variant_raw object is *not* copied at
+        # this place because the attribute points to the same object
+        # as self.diag_layer_raw.
+        result.ecu_variant_raw = deepcopy(self.ecu_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 isinstance(dl.diag_layer_raw, HasDiagVariables):
+                return []
+
+            return dl.diag_layer_raw.diag_variables
+
+        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 isinstance(dl.diag_layer_raw, HasVariableGroups):
+                return []
+
+            return dl.diag_layer_raw.variable_groups
+
+        def not_inherited_fn(parent_ref: ParentRef) -> List[str]:
+            return []
+
+        return self._compute_available_objects(get_local_objects_fn, not_inherited_fn)

odxtools/diaglayers/ecuvariantraw.py

@@ -0,0 +1,129 @@
+# 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 ..ecuvariantpattern import EcuVariantPattern
+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 EcuVariantRaw(HierarchyElementRaw):
+    diag_variables_raw: List[Union[DiagVariable, OdxLinkRef]]
+    variable_groups: NamedItemList[VariableGroup]
+    ecu_variant_patterns: List[EcuVariantPattern]
+    dyn_defined_spec: Optional[DynDefinedSpec]
+    parent_refs: List[ParentRef]
+
+    @property
+    def diag_variables(self) -> NamedItemList[DiagVariable]:
+        return self._diag_variables
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element,
+                doc_frags: List[OdxDocFragment]) -> "EcuVariantRaw":
+        # objects contained by diagnostic layers exibit an additional
+        # document fragment for the diag layer, so we use the document
+        # fragments of the odx id of the diag layer for IDs of
+        # contained objects.
+        her = HierarchyElementRaw.from_et(et_element, doc_frags)
+        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")
+        ])
+
+        ecu_variant_patterns = None
+        ecu_variant_patterns = [
+            EcuVariantPattern.from_et(varpat_elem, doc_frags)
+            for varpat_elem in et_element.iterfind("ECU-VARIANT-PATTERNS/ECU-VARIANT-PATTERN")
+        ]
+
+        dyn_defined_spec = None
+        if (dds_elem := et_element.find("DYN-DEFINED-SPEC")) is not None:
+            dyn_defined_spec = DynDefinedSpec.from_et(dds_elem, doc_frags)
+
+        parent_refs = [
+            ParentRef.from_et(pr_el, doc_frags)
+            for pr_el in et_element.iterfind("PARENT-REFS/PARENT-REF")
+        ]
+
+        # Create DiagLayer
+        return EcuVariantRaw(
+            diag_variables_raw=diag_variables_raw,
+            variable_groups=variable_groups,
+            ecu_variant_patterns=ecu_variant_patterns,
+            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)

odxtools/diaglayers/functionalgroup.py

@@ -0,0 +1,110 @@
+# SPDX-License-Identifier: MIT
+from copy import deepcopy
+from dataclasses import dataclass
+from typing import Any, Dict, Iterable, List, Union, cast
+from xml.etree import ElementTree
+
+from typing_extensions import override
+
+from ..diagvariable import DiagVariable
+from ..exceptions import odxassert
+from ..nameditemlist import NamedItemList
+from ..odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkRef
+from ..parentref import ParentRef
+from ..variablegroup import VariableGroup
+from .diaglayer import DiagLayer
+from .functionalgroupraw import FunctionalGroupRaw
+from .hierarchyelement import HierarchyElement
+
+
+@dataclass
+class FunctionalGroup(HierarchyElement):
+    """This is a diagnostic layer for functionality shared between multiple ECU variants
+    """
+
+    @property
+    def functional_group_raw(self) -> FunctionalGroupRaw:
+        return cast(FunctionalGroupRaw, self.diag_layer_raw)
+
+    @property
+    def diag_variables_raw(self) -> List[Union[DiagVariable, OdxLinkRef]]:
+        return self.functional_group_raw.diag_variables_raw
+
+    @property
+    def diag_variables(self) -> NamedItemList[DiagVariable]:
+        return self._diag_variables
+
+    @property
+    def variable_groups(self) -> NamedItemList[VariableGroup]:
+        return self._variable_groups
+
+    @property
+    def parent_refs(self) -> List[ParentRef]:
+        return self.functional_group_raw.parent_refs
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element,
+                doc_frags: List[OdxDocFragment]) -> "FunctionalGroup":
+        functional_group_raw = FunctionalGroupRaw.from_et(et_element, doc_frags)
+
+        return FunctionalGroup(diag_layer_raw=functional_group_raw)
+
+    def __post_init__(self) -> None:
+        super().__post_init__()
+
+        odxassert(
+            isinstance(self.diag_layer_raw, FunctionalGroupRaw),
+            "The raw diagnostic layer passed to FunctionalGroup "
+            "must be a FunctionalGroupRaw")
+
+    @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)
+
+    def __deepcopy__(self, memo: Dict[int, Any]) -> Any:
+        """Create a deep copy of the functional group layer
+
+        Note that the copied diagnostic layer is not fully
+        initialized, so `_finalize_init()` should to be called on it
+        before it can be used normally.
+        """
+
+        result = super().__deepcopy__(memo)
+
+        # note that the self.functional_group_raw object is *not* copied at
+        # this place because the attribute points to the same object
+        # as self.diag_layer_raw.
+        result.functional_group_raw = deepcopy(self.functional_group_raw, memo)
+
+        return result

odxtools/diaglayers/functionalgroupraw.py

@@ -0,0 +1,106 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass
+from typing import Any, Dict, List, Union
+from xml.etree import ElementTree
+
+from ..diagvariable import DiagVariable
+from ..exceptions import odxraise
+from ..nameditemlist import NamedItemList
+from ..odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef
+from ..parentref import ParentRef
+from ..snrefcontext import SnRefContext
+from ..utils import dataclass_fields_asdict
+from ..variablegroup import VariableGroup
+from .hierarchyelementraw import HierarchyElementRaw
+
+
+@dataclass
+class FunctionalGroupRaw(HierarchyElementRaw):
+    """This is a diagnostic layer for common functionality of an ECU
+    """
+
+    diag_variables_raw: List[Union[DiagVariable, OdxLinkRef]]
+    variable_groups: NamedItemList[VariableGroup]
+    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]) -> "FunctionalGroupRaw":
+        # 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")
+        ])
+
+        parent_refs = [
+            ParentRef.from_et(pr_elem, doc_frags)
+            for pr_elem in et_element.iterfind("PARENT-REFS/PARENT-REF")
+        ]
+
+        return FunctionalGroupRaw(
+            diag_variables_raw=diag_variables_raw,
+            variable_groups=variable_groups,
+            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())
+
+        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)
+
+        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)
+
+        for parent_ref in self.parent_refs:
+            parent_ref._resolve_snrefs(context)