odxtools 7.4.0__py3-none-any.whl → 8.0.0__py3-none-any.whl

odxtools/diaglayers/hierarchyelementraw.py

@@ -0,0 +1,52 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass
+from typing import Any, Dict, List
+from xml.etree import ElementTree
+
+from ..comparaminstance import ComparamInstance
+from ..odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
+from ..snrefcontext import SnRefContext
+from ..utils import dataclass_fields_asdict
+from .diaglayerraw import DiagLayerRaw
+
+
+@dataclass
+class HierarchyElementRaw(DiagLayerRaw):
+    """This is the base class for diagnostic layers that may be involved in value inheritance
+
+    This class represents the data present in the XML, not the "logical" view.
+    """
+
+    comparam_refs: List[ComparamInstance]
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element,
+                doc_frags: List[OdxDocFragment]) -> "HierarchyElementRaw":
+        kwargs = dataclass_fields_asdict(DiagLayerRaw.from_et(et_element, doc_frags))
+
+        comparam_refs = [
+            ComparamInstance.from_et(el, doc_frags)
+            for el in et_element.iterfind("COMPARAM-REFS/COMPARAM-REF")
+        ]
+
+        return HierarchyElementRaw(comparam_refs=comparam_refs, **kwargs)
+
+    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+        result = super()._build_odxlinks()
+
+        for comparam_ref in self.comparam_refs:
+            result.update(comparam_ref._build_odxlinks())
+
+        return result
+
+    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
+        super()._resolve_odxlinks(odxlinks)
+
+        for comparam_ref in self.comparam_refs:
+            comparam_ref._resolve_odxlinks(odxlinks)
+
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
+        super()._resolve_snrefs(context)
+
+        for comparam_ref in self.comparam_refs:
+            comparam_ref._resolve_snrefs(context)

odxtools/diaglayers/protocol.py

@@ -0,0 +1,64 @@
+# SPDX-License-Identifier: MIT
+from copy import deepcopy
+from dataclasses import dataclass
+from typing import Any, Dict, List, Optional, cast
+from xml.etree import ElementTree
+
+from ..comparamspec import ComparamSpec
+from ..exceptions import odxassert
+from ..odxlink import OdxDocFragment
+from ..protstack import ProtStack
+from .hierarchyelement import HierarchyElement
+from .protocolraw import ProtocolRaw
+
+
+@dataclass
+class Protocol(HierarchyElement):
+    """This is the class for primitives that are common for a given communication protocol
+
+    Most importantly this diagnostic layer is responsible for defining
+    the communication parameters that ought to be used.
+    """
+
+    @property
+    def protocol_raw(self) -> ProtocolRaw:
+        return cast(ProtocolRaw, self.diag_layer_raw)
+
+    @property
+    def comparam_spec(self) -> ComparamSpec:
+        return self.protocol_raw.comparam_spec
+
+    @property
+    def prot_stack(self) -> Optional[ProtStack]:
+        return self.protocol_raw.prot_stack
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "Protocol":
+        protocol_raw = ProtocolRaw.from_et(et_element, doc_frags)
+
+        return Protocol(diag_layer_raw=protocol_raw)
+
+    def __post_init__(self) -> None:
+        super().__post_init__()
+
+        odxassert(
+            isinstance(self.diag_layer_raw, ProtocolRaw),
+            "The raw diagnostic layer passed to Protocol "
+            "must be a ProtocolRaw")
+
+    def __deepcopy__(self, memo: Dict[int, Any]) -> Any:
+        """Create a deep copy of the protocol 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.protocol_raw object is *not* copied at
+        # this place because the attribute points to the same object
+        # as self.diag_layer_raw.
+        result.protocol_raw = deepcopy(self.protocol_raw, memo)
+
+        return result

odxtools/diaglayers/protocolraw.py

@@ -0,0 +1,85 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass
+from typing import Any, Dict, List, Optional
+from xml.etree import ElementTree
+
+from ..comparamspec import ComparamSpec
+from ..exceptions import odxrequire
+from ..odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef, resolve_snref
+from ..parentref import ParentRef
+from ..protstack import ProtStack
+from ..snrefcontext import SnRefContext
+from ..utils import dataclass_fields_asdict
+#from .comparaminstance import ComparamInstance
+from .hierarchyelementraw import HierarchyElementRaw
+
+
+@dataclass
+class ProtocolRaw(HierarchyElementRaw):
+    """This is the base class for diagnostic layers that describe a
+    protocol which can be used to communicate with an ECU
+
+    This class represents the data present in the XML, not the "logical" view.
+
+    """
+
+    comparam_spec_ref: OdxLinkRef
+    prot_stack_snref: Optional[str]
+    parent_refs: List[ParentRef]
+
+    @property
+    def comparam_spec(self) -> ComparamSpec:
+        return self._comparam_spec
+
+    @property
+    def prot_stack(self) -> Optional[ProtStack]:
+        return self._prot_stack
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "ProtocolRaw":
+        kwargs = dataclass_fields_asdict(HierarchyElementRaw.from_et(et_element, doc_frags))
+
+        comparam_spec_ref = OdxLinkRef.from_et(
+            odxrequire(et_element.find("COMPARAM-SPEC-REF")), doc_frags)
+
+        prot_stack_snref = None
+        if (prot_stack_snref_elem := et_element.find("PROT-STACK-SNREF")) is not None:
+            prot_stack_snref = odxrequire(prot_stack_snref_elem.get("SHORT-NAME"))
+
+        parent_refs = [
+            ParentRef.from_et(pr_el, doc_frags)
+            for pr_el in et_element.iterfind("PARENT-REFS/PARENT-REF")
+        ]
+
+        return ProtocolRaw(
+            comparam_spec_ref=comparam_spec_ref,
+            prot_stack_snref=prot_stack_snref,
+            parent_refs=parent_refs,
+            **kwargs)
+
+    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+        result = super()._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)
+
+        for parent_ref in self.parent_refs:
+            parent_ref._resolve_odxlinks(odxlinks)
+
+        self._comparam_spec = odxlinks.resolve(self.comparam_spec_ref, ComparamSpec)
+
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
+        super()._resolve_snrefs(context)
+
+        self._prot_stack = None
+        if self.prot_stack_snref is not None:
+            self._prot_stack = resolve_snref(self.prot_stack_snref, self._comparam_spec.prot_stacks,
+                                             ProtStack)
+
+        for parent_ref in self.parent_refs:
+            parent_ref._resolve_snrefs(context)

odxtools/diagvariable.py

@@ -1,6 +1,7 @@
 # SPDX-License-Identifier: MIT
+import typing
 from dataclasses import dataclass
-from typing import Any, Dict, List, Optional
+from typing import Any, Dict, List, Optional, runtime_checkable
 from xml.etree import ElementTree
 
 from .admindata import AdminData
@@ -17,6 +18,14 @@ from .utils import dataclass_fields_asdict
 from .variablegroup import VariableGroup
 
 
+@runtime_checkable
+class HasDiagVariables(typing.Protocol):
+
+    @property
+    def diag_variables(self) -> "NamedItemList[DiagVariable]":
+        ...
+
+
 @dataclass
 class DiagVariable(IdentifiableElement):
     """Representation of a diagnostic variable

odxtools/ecuvariantmatcher.py

@@ -2,10 +2,11 @@
 from enum import Enum
 from typing import Dict, Generator, List, Optional
 
-from .diaglayer import DiagLayer
-from .diaglayertype import DiagLayerType
+from .diaglayers.diaglayer import DiagLayer
+from .diaglayers.diaglayertype import DiagLayerType
+from .diaglayers.ecuvariant import EcuVariant
 from .diagservice import DiagService
-from .exceptions import OdxError, odxassert
+from .exceptions import OdxError, odxassert, odxrequire
 from .matchingparameter import MatchingParameter
 from .odxtypes import ParameterValue
 from .response import Response
@@ -42,9 +43,7 @@ class EcuVariantMatcher:
     @staticmethod
     def get_ident_service(diag_layer: DiagLayer, matching_param: MatchingParameter) -> DiagService:
         service_name = matching_param.diag_comm_snref
-        odxassert(service_name in [x.short_name for x in diag_layer.services])
-        service = diag_layer.services[service_name]
-        odxassert(isinstance(service, DiagService))
+        service = odxrequire(diag_layer.services.get(service_name))
         return service
 
     @staticmethod
@@ -89,7 +88,7 @@ class EcuVariantMatcher:
         raise OdxError(f"The snref or snpathref '{matching_param.out_param_if}' is cannot be \
                 resolved for any positive or negative response.")
 
-    def __init__(self, ecu_variant_candidates: List[DiagLayer], use_cache: bool = True):
+    def __init__(self, ecu_variant_candidates: List[EcuVariant], use_cache: bool = True):
 
         self.ecus = ecu_variant_candidates
         for ecu in self.ecus:

odxtools/field.py

@@ -81,12 +81,11 @@ class Field(ComplexDop):
 
     def _resolve_snrefs(self, context: SnRefContext) -> None:
         """Recursively resolve any short-name references"""
-        ddd_spec = odxrequire(context.diag_layer).diag_data_dictionary_spec
+        ddds = odxrequire(context.diag_layer).diag_data_dictionary_spec
 
         if self.structure_snref is not None:
-            self._structure = resolve_snref(self.structure_snref, ddd_spec.structures,
-                                            BasicStructure)
+            self._structure = resolve_snref(self.structure_snref, ddds.structures, BasicStructure)
 
         if self.env_data_desc_snref is not None:
-            self._env_data_desc = resolve_snref(self.env_data_desc_snref, ddd_spec.env_data_descs,
+            self._env_data_desc = resolve_snref(self.env_data_desc_snref, ddds.env_data_descs,
                                                 EnvironmentDataDescription)

odxtools/matchingparameter.py

@@ -12,7 +12,7 @@ from .utils import is_short_name, is_short_name_path
 class MatchingParameter:
     """According to ISO 22901, a MatchingParameter contains a string value identifying
     the active ECU variant. Moreover, it references a DIAG-COMM via snref and one of its
-    positiv response's OUT-PARAM-IF via snref or snpathref.
+    positive response's OUT-PARAM-IF via snref or snpathref.
 
     Unlike other parameters defined in the `parameters` package, a MatchingParameter is
     not transferred over the network.

odxtools/nameditemlist.py

@@ -1,15 +1,16 @@
 # SPDX-License-Identifier: MIT
 import abc
+import typing
 from copy import deepcopy
 from keyword import iskeyword
-from typing import (Any, Collection, Dict, Iterable, List, Optional, Protocol, SupportsIndex, Tuple,
-                    TypeVar, Union, cast, overload, runtime_checkable)
+from typing import (Any, Collection, Dict, Iterable, List, Optional, SupportsIndex, Tuple, TypeVar,
+                    Union, cast, overload, runtime_checkable)
 
 from .exceptions import odxraise
 
 
 @runtime_checkable
-class OdxNamed(Protocol):
+class OdxNamed(typing.Protocol):
 
     @property
     def short_name(self) -> str:

odxtools/parameterinfo.py

@@ -132,7 +132,16 @@ def parameter_info(param_list: Iterable[Parameter], quoted_names: bool = False)
                 val_str = ""
                 if scale.lower_limit is not None:
                     val_str = f"({repr(scale.lower_limit.value)})"
-                of.write(f"  {repr(scale.compu_const)}{val_str}\n")
+
+                if scale.compu_const is None:
+                    of.write(f"  <ERROR in ODX data: no value specified>\n")
+                else:
+                    vt = scale.compu_const.vt
+                    v = scale.compu_const.v
+                    if vt is not None:
+                        of.write(f"  \"{vt}\" {val_str}\n")
+                    else:
+                        of.write(f"  {v}\n")
 
         elif isinstance(cm, IdenticalCompuMethod):
             bdt = dop.physical_type.base_data_type

odxtools/parameters/parameterwithdop.py

@@ -60,9 +60,8 @@ class ParameterWithDOP(Parameter):
         super()._resolve_snrefs(context)
 
         if self.dop_snref:
-            all_dops = odxrequire(
-                context.diag_layer).diag_data_dictionary_spec.all_data_object_properties
-            self._dop = resolve_snref(self.dop_snref, all_dops, DopBase)
+            ddds = odxrequire(context.diag_layer).diag_data_dictionary_spec
+            self._dop = resolve_snref(self.dop_snref, ddds.all_data_object_properties, DopBase)
 
     @property
     def dop(self) -> DopBase:

odxtools/parentref.py

@@ -10,7 +10,7 @@ from .snrefcontext import SnRefContext
 from .utils import dataclass_fields_asdict
 
 if TYPE_CHECKING:
-    from .diaglayer import DiagLayer
+    from .diaglayers.diaglayer import DiagLayer
 
 
 @dataclass

odxtools/snrefcontext.py

@@ -4,7 +4,7 @@ from typing import TYPE_CHECKING, List, Optional
 
 if TYPE_CHECKING:
     from .database import Database
-    from .diaglayer import DiagLayer
+    from .diaglayers.diaglayer import DiagLayer
     from .diagservice import DiagService
     from .parameters.parameter import Parameter
     from .request import Request

odxtools/templates/diag_layer_container.odx-d.xml.jinja2

@@ -2,10 +2,15 @@
  #
  # SPDX-License-Identifier: MIT
 -#}
-{%- import('macros/printVariant.xml.jinja2') as pv -%}
 {%- import('macros/printAdminData.xml.jinja2') as pad -%}
 {%- import('macros/printCompanyData.xml.jinja2') as pcd -%}
 {%- import('macros/printSpecialData.xml.jinja2') as psd %}
+{%- import('macros/printEcuSharedData.xml.jinja2') as pecusd -%}
+{%- import('macros/printProtocol.xml.jinja2') as pprot %}
+{%- import('macros/printFunctionalGroup.xml.jinja2') as pfuncgroup %}
+{%- import('macros/printEcuSharedData.xml.jinja2') as pecusd %}
+{%- import('macros/printBaseVariant.xml.jinja2') as pbv %}
+{%- import('macros/printEcuVariant.xml.jinja2') as pecuv %}
 {#- -#}
 
 <?xml version="1.0" encoding="UTF-8" standalone="no" ?>
@@ -35,35 +40,35 @@
 {%- if dlc.protocols %}
   <PROTOCOLS>
  {%- for dl in dlc.protocols %}
-   {{pv.printVariant(dl)|indent(3)}}
+   {{pprot.printProtocol(dl)|indent(3)}}
  {%- endfor %}
   </PROTOCOLS>
 {%- endif %}
 {%- if dlc.functional_groups %}
   <FUNCTIONAL-GROUPS>
  {%- for dl in dlc.functional_groups %}
-  {{pv.printVariant(dl)|indent(3)}}
+  {{pfuncgroup.printFunctionalGroup(dl)|indent(3)}}
  {%- endfor %}
   </FUNCTIONAL-GROUPS>
 {%- endif %}
 {%- if dlc.ecu_shared_datas %}
   <ECU-SHARED-DATAS>
  {%- for dl in dlc.ecu_shared_datas %}
-  {{pv.printVariant(dl)|indent(3)}}
+  {{pecusd.printEcuSharedData(dl)|indent(3)}}
  {%- endfor %}
   </ECU-SHARED-DATAS>
 {%- endif %}
 {%- if dlc.base_variants %}
   <BASE-VARIANTS>
  {%- for dl in dlc.base_variants %}
-  {{pv.printVariant(dl)|indent(3)}}
+  {{pbv.printBaseVariant(dl)|indent(3)}}
  {%- endfor %}
   </BASE-VARIANTS>
 {%- endif %}
 {%- if  dlc.ecu_variants %}
   <ECU-VARIANTS>
  {%- for dl in dlc.ecu_variants %}
-  {{pv.printVariant(dl)|indent(3)}}
+  {{pecuv.printEcuVariant(dl)|indent(3)}}
  {%- endfor %}
   </ECU-VARIANTS>
 {%- endif %}

odxtools/templates/macros/printBaseVariant.xml.jinja2

@@ -0,0 +1,53 @@
+{#- -*- mode: sgml; tab-width: 2; indent-tabs-mode: nil -*-
+ #
+ # SPDX-License-Identifier: MIT
+-#}
+
+{%- import('macros/printHierarchyElement.xml.jinja2') as phe %}
+{%- import('macros/printComparamRef.xml.jinja2') as pcom %}
+{%- import('macros/printParentRef.xml.jinja2') as pparref %}
+
+{%- macro printBaseVariant(base_variant) -%}
+<BASE-VARIANT {{- phe.printHierarchyElementAttribs(base_variant) -}}>
+  {{ phe.printHierarchyElementSubtags(base_variant) | indent(2) }}
+  {%- set dlr = base_variant.base_variant_raw %}
+
+  {%- if dlr.diag_variables %}
+  <DIAG-VARIABLES>
+    {%- for dv in dlr.diag_variables -%}
+    {{ pdv.printDiagVariable(dv)|indent(4) }}
+    {%- endfor -%}
+  </DIAG-VARIABLES>
+  {%- endif %}
+
+  {%- if dlr.variable_groups %}
+  <VARIABLE-GROUPS>
+    {%- for vg in dlr.variable_groups -%}
+    {{ pdv.printVariableGroup(vg)|indent(4) }}
+    {%- endfor -%}
+  </VARIABLE-GROUPS>
+  {%- endif %}
+
+  {%- if dlr.dyn_defined_spec %}
+  {{ pdynspec.printPrintDefinedSpec(dlr.dyn_defined_spec)|indent(4) }}
+  {%- endif %}
+
+{#
+  {%- if dlr.base_variant_patterns %}
+  <BASE-VARIANT-PATTERNS>
+    {%- for vp in dlr.base_variant_patterns -%}
+    {{ pvpat.printBaseVariantPattern(vp)|indent(4) }}
+    {%- endfor -%}
+  </BASE-VARIANT-PATTERNS>
+  {%- endif %}
+#}
+
+  {%- if dlr.parent_refs %}
+  <PARENT-REFS>
+    {%- for parent in dlr.parent_refs -%}
+    {{ pparref.printParentRef(parent)|indent(4) }}
+    {%- endfor %}
+  </PARENT-REFS>
+  {%- endif %}
+</BASE-VARIANT>
+{%- endmacro %}

odxtools/templates/macros/printCompuMethod.xml.jinja2

@@ -18,7 +18,7 @@
 {%- if limit_obj.value_raw is none %}
   {#- #}/>
 {%- else %}
-  {#- #}>{{- limit_obj.value_raw }}</{{tag_name}}>
+  {#- #}>{{- limit_obj.value_raw | e }}</{{tag_name}}>
 {%- endif -%}
 {%- endif -%}
 {%- endmacro -%}