odxtools 10.2.0__py3-none-any.whl → 10.3.0__py3-none-any.whl

odxtools/isotp_state_machine.py

@@ -44,7 +44,7 @@ class IsoTpStateMachine:
         self._telegram_data: list[bytearray | None] = [None] * len(can_rx_ids)
         self._telegram_last_rx_fragment_idx = [0] * len(can_rx_ids)
 
-    def decode_rx_frame(self, rx_id: int, data: bytes) -> Iterable[tuple[int, bytes]]:
+    def decode_rx_frame(self, rx_id: int, data: bytes | bytearray) -> Iterable[tuple[int, bytes]]:
         """Handle the ISO-TP state transitions caused by a CAN frame.
 
         E.g., add some data to a telegram, etc. Returns a generator of
@@ -67,7 +67,7 @@ class IsoTpStateMachine:
             self.on_single_frame(telegram_idx, data[1:1 + telegram_len])
             self.on_telegram_complete(telegram_idx, data[1:1 + telegram_len])
 
-            yield (rx_id, data[1:1 + telegram_len])
+            yield (rx_id, bytes(data[1:1 + telegram_len]))
 
         elif frame_type == IsoTp.FRAME_TYPE_FIRST:
             frame_type, telegram_len = bitstruct.unpack("u4u12", data)
@@ -105,7 +105,7 @@ class IsoTpStateMachine:
                 self.on_sequence_error(telegram_idx, expected_segment_idx, rx_segment_idx)
             elif len(telegram_data) == n:
                 self.on_telegram_complete(telegram_idx, telegram_data)
-                yield (rx_id, telegram_data)
+                yield (rx_id, bytes(telegram_data))
 
         elif frame_type == IsoTp.FRAME_TYPE_FLOW_CONTROL:
             frame_type, flow_control_flag = bitstruct.unpack("u4u4", data)
@@ -185,7 +185,7 @@ class IsoTpStateMachine:
         """
         return self._can_rx_ids[telegram_idx]
 
-    def telegram_data(self, telegram_idx: int) -> bytes | None:
+    def telegram_data(self, telegram_idx: int) -> bytearray | None:
         """Given a Telegram index, returns the data received for this telegram
         so far.
 
@@ -196,16 +196,16 @@ class IsoTpStateMachine:
     ##############
     # Callbacks
     ##############
-    def on_single_frame(self, telegram_idx: int, frame_payload: bytes) -> None:
+    def on_single_frame(self, telegram_idx: int, frame_payload: bytes | bytearray) -> None:
         """Callback method for when an ISO-TP message of type "single frame" has been received"""
         pass
 
-    def on_first_frame(self, telegram_idx: int, frame_payload: bytes) -> None:
+    def on_first_frame(self, telegram_idx: int, frame_payload: bytes | bytearray) -> None:
         """Callback method for when an ISO-TP message of type "first frame" has been received"""
         pass
 
     def on_consecutive_frame(self, telegram_idx: int, segment_idx: int,
-                             frame_payload: bytes) -> None:
+                             frame_payload: bytes | bytearray) -> None:
         """Callback method for when an ISO-TP message of type "consecutive frame" has been received"""
         pass
 
@@ -221,7 +221,7 @@ class IsoTpStateMachine:
         """Method called when a frame exhibiting an unknown frame type has been received"""
         pass
 
-    def on_telegram_complete(self, telegram_idx: int, telegram_payload: bytes) -> None:
+    def on_telegram_complete(self, telegram_idx: int, telegram_payload: bytes | bytearray) -> None:
         """Method called when an ISO-TP telegram has been fully received"""
         pass
 
@@ -264,7 +264,7 @@ class IsoTpActiveDecoder(IsoTpStateMachine):
         """
         return self._can_tx_ids[telegram_idx]
 
-    def on_single_frame(self, telegram_idx: int, frame_payload: bytes) -> None:
+    def on_single_frame(self, telegram_idx: int, frame_payload: bytes | bytearray) -> None:
         # send ACK
         # rx_id = self.can_rx_id(telegram_idx)
         tx_id = self.can_tx_id(telegram_idx)
@@ -283,7 +283,7 @@ class IsoTpActiveDecoder(IsoTpStateMachine):
 
         super().on_first_frame(telegram_idx, frame_payload)
 
-    def on_first_frame(self, telegram_idx: int, frame_payload: bytes) -> None:
+    def on_first_frame(self, telegram_idx: int, frame_payload: bytes | bytearray) -> None:
         # send ACK
         # rx_id = self.can_rx_id(telegram_idx)
         tx_id = self.can_tx_id(telegram_idx)
@@ -306,7 +306,7 @@ class IsoTpActiveDecoder(IsoTpStateMachine):
         super().on_first_frame(telegram_idx, frame_payload)
 
     def on_consecutive_frame(self, telegram_idx: int, segment_idx: int,
-                             frame_payload: bytes) -> None:
+                             frame_payload: bytes | bytearray) -> None:
         num_received = self._frames_received[telegram_idx]
         if num_received is None:
             # consequtive frame received before a first frame.

odxtools/itemvalue.py

@@ -0,0 +1,77 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass, field
+from typing import Any
+from xml.etree import ElementTree
+
+from .audience import Audience
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkId
+from .snrefcontext import SnRefContext
+from .specialdatagroup import SpecialDataGroup
+from .text import Text
+
+
+@dataclass(kw_only=True)
+class ItemValue:
+    """This class represents a ITEM-VALUE."""
+
+    phys_constant_value: str | None
+    meaning: Text | None = None
+    key: str | None = None
+    rule: str | None = None
+    description: Text | None = None
+    sdgs: list[SpecialDataGroup] = field(default_factory=list)
+    audience: Audience | None = None
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "ItemValue":
+        phys_constant_value = et_element.findtext("PHYS-CONSTANT-VALUE")
+
+        meaning = None
+        if (meaning_elem := et_element.find("MEANING")) is not None:
+            meaning = Text.from_et(meaning_elem, context)
+
+        key = et_element.findtext("KEY")
+        rule = et_element.findtext("RULE")
+
+        description = None
+        if (description_elem := et_element.find("DESCRIPTION")) is not None:
+            description = Text.from_et(description_elem, context)
+
+        sdgs = [SpecialDataGroup.from_et(sdge, context) for sdge in et_element.iterfind("SDGS/SDG")]
+
+        audience = None
+        if (aud_elem := et_element.find("AUDIENCE")) is not None:
+            audience = Audience.from_et(aud_elem, context)
+
+        return ItemValue(
+            phys_constant_value=phys_constant_value,
+            meaning=meaning,
+            key=key,
+            rule=rule,
+            description=description,
+            sdgs=sdgs,
+            audience=audience,
+        )
+
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
+        result = {}
+
+        if self.audience is not None:
+            result.update(self.audience._build_odxlinks())
+        for sdg in self.sdgs:
+            result.update(sdg._build_odxlinks())
+
+        return result
+
+    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
+        if self.audience is not None:
+            self.audience._resolve_odxlinks(odxlinks)
+        for sdg in self.sdgs:
+            sdg._resolve_odxlinks(odxlinks)
+
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
+        if self.audience is not None:
+            self.audience._resolve_snrefs(context)
+        for sdg in self.sdgs:
+            sdg._resolve_snrefs(context)

odxtools/nameditemlist.py

@@ -4,7 +4,7 @@ import typing
 from collections.abc import Collection, Iterable
 from copy import deepcopy
 from keyword import iskeyword
-from typing import Any, SupportsIndex, TypeVar, cast, overload, runtime_checkable
+from typing import Any, SupportsIndex, TypeVar, overload, runtime_checkable
 
 from .exceptions import odxraise
 
@@ -159,7 +159,7 @@ class ItemAttributeList(list[T]):
                 return super().__getitem__(key)
             return default
         else:
-            return cast(T | None, self._item_dict.get(key, default))
+            return self._item_dict.get(key, default)
 
     def __eq__(self, other: object) -> bool:
         """

odxtools/odxlink.py

@@ -204,8 +204,10 @@ class OdxLinkDatabase:
             # locate an object exhibiting with the referenced local ID
             # in the ID database for the document fragment
             if (obj := doc_frag_db.get(ref.ref_id)) is not None:
-                if expected_type is not None:
-                    odxassert(isinstance(obj, expected_type))
+                if expected_type is not None and not isinstance(obj, expected_type):
+                    odxraise(f"Referenced object for link {ref.ref_id} is of type "
+                             f"{type(obj).__name__} which is not a subclass of expected "
+                             f"type {expected_type.__name__}")
 
                 return obj
 

odxtools/optionitem.py

@@ -0,0 +1,79 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass, field
+from typing import Any
+from xml.etree import ElementTree
+
+from .audience import Audience
+from .configitem import ConfigItem
+from .itemvalue import ItemValue
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkId
+from .snrefcontext import SnRefContext
+from .utils import dataclass_fields_asdict
+
+
+@dataclass(kw_only=True)
+class OptionItem(ConfigItem):
+    """This class represents a OPTION-ITEM."""
+
+    physical_default_value: str | None = None
+    item_values: list[ItemValue] = field(default_factory=list)
+    write_audience: Audience | None = None
+    read_audience: Audience | None = None
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "OptionItem":
+        kwargs = dataclass_fields_asdict(ConfigItem.from_et(et_element, context))
+
+        physical_default_value = et_element.findtext("PHYSICAL-DEFAULT-VALUE")
+
+        item_values = [
+            ItemValue.from_et(el, context) for el in et_element.iterfind("ITEM-VALUES/ITEM-VALUE")
+        ]
+
+        write_audience = None
+        if (wa_elem := et_element.find("WRITE-AUDIENCE")) is not None:
+            write_audience = Audience.from_et(wa_elem, context)
+
+        read_audience = None
+        if (ra_elem := et_element.find("READ-AUDIENCE")) is not None:
+            read_audience = Audience.from_et(ra_elem, context)
+
+        return OptionItem(
+            physical_default_value=physical_default_value,
+            item_values=item_values,
+            write_audience=write_audience,
+            read_audience=read_audience,
+            **kwargs)
+
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
+        result = super()._build_odxlinks()
+
+        for item_value in self.item_values:
+            result.update(item_value._build_odxlinks())
+        if self.write_audience is not None:
+            result.update(self.write_audience._build_odxlinks())
+        if self.read_audience is not None:
+            result.update(self.read_audience._build_odxlinks())
+
+        return result
+
+    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
+        super()._resolve_odxlinks(odxlinks)
+
+        for item_value in self.item_values:
+            item_value._resolve_odxlinks(odxlinks)
+        if self.write_audience is not None:
+            self.write_audience._resolve_odxlinks(odxlinks)
+        if self.read_audience is not None:
+            self.read_audience._resolve_odxlinks(odxlinks)
+
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
+        super()._resolve_snrefs(context)
+
+        for item_value in self.item_values:
+            item_value._resolve_snrefs(context)
+        if self.write_audience is not None:
+            self.write_audience._resolve_snrefs(context)
+        if self.read_audience is not None:
+            self.read_audience._resolve_snrefs(context)

odxtools/parameters/codedconstparameter.py

@@ -1,7 +1,7 @@
 # SPDX-License-Identifier: MIT
 import warnings
 from dataclasses import dataclass
-from typing import Any, cast
+from typing import Any
 from xml.etree import ElementTree
 
 from typing_extensions import override
@@ -57,8 +57,7 @@ class CodedConstParameter(Parameter):
             coded_value_raw=coded_value_raw, diag_coded_type=diag_coded_type, **kwargs)
 
     def __post_init__(self) -> None:
-        self._coded_value = cast(
-            AtomicOdxType, self.diag_coded_type.base_data_type.from_string(self.coded_value_raw))
+        self._coded_value = self.diag_coded_type.base_data_type.from_string(self.coded_value_raw)
 
     @override
     def _build_odxlinks(self) -> dict[OdxLinkId, Any]:

odxtools/readdiagcommconnector.py

@@ -0,0 +1,79 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass
+from typing import Any
+from xml.etree import ElementTree
+
+from .diagcomm import DiagComm
+from .exceptions import odxrequire
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkId, OdxLinkRef
+from .readparamvalue import ReadParamValue
+from .snrefcontext import SnRefContext
+
+
+@dataclass(kw_only=True)
+class ReadDiagCommConnector:
+    read_param_values: list[ReadParamValue]
+
+    # exactly one of the following attributes must be non-None
+    read_diag_comm_ref: OdxLinkRef | None = None
+    read_diag_comm_snref: str | None = None
+
+    # exactly one of the following attributes must be non-None
+    read_data_snref: str | None = None
+    read_data_snpathref: str | None = None
+
+    @property
+    def read_diag_comm(self) -> DiagComm | None:
+        return self._read_diag_comm
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "ReadDiagCommConnector":
+        read_param_values = [
+            ReadParamValue.from_et(el, context)
+            for el in et_element.iterfind("READ-PARAM-VALUES/READ-PARAM-VALUE")
+        ]
+
+        read_diag_comm_ref = OdxLinkRef.from_et(et_element.find("READ-DIAG-COMM-REF"), context)
+        read_diag_comm_snref = None
+        if (read_diag_comm_snref_elem := et_element.find("READ-DIAG-COMM-SNREF")) is not None:
+            read_diag_comm_snref = odxrequire(read_diag_comm_snref_elem.attrib.get("SHORT-NAME"))
+
+        read_data_snref = None
+        if (read_data_snref_elem := et_element.find("READ-DATA-SNREF")) is not None:
+            read_data_snref = odxrequire(read_data_snref_elem.attrib.get("SHORT-NAME"))
+
+        read_data_snpathref = None
+        if (read_data_snpathref_elem := et_element.find("READ-DATA-SNPATHREF")) is not None:
+            read_data_snpathref = odxrequire(read_data_snpathref_elem.attrib.get("SHORT-NAME-PATH"))
+
+        return ReadDiagCommConnector(
+            read_param_values=read_param_values,
+            read_diag_comm_ref=read_diag_comm_ref,
+            read_diag_comm_snref=read_diag_comm_snref,
+            read_data_snref=read_data_snref,
+            read_data_snpathref=read_data_snpathref,
+        )
+
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
+        odxlinks = {}
+
+        for rpv in self.read_param_values:
+            odxlinks.update(rpv._build_odxlinks())
+
+        return odxlinks
+
+    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
+        self._read_diag_comm = None
+        if self.read_diag_comm_ref is not None:
+            self._read_diag_comm = odxlinks.resolve(self.read_diag_comm_ref, DiagComm)
+
+        for rpv in self.read_param_values:
+            rpv._resolve_odxlinks(odxlinks)
+
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
+        # read_diag_comm_snref cannot be uniquely resolved ahead of
+        # time as it depends on the diag layer which is used
+
+        for rpv in self.read_param_values:
+            rpv._resolve_snrefs(context)

odxtools/readparamvalue.py

@@ -0,0 +1,52 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass
+from typing import Any
+from xml.etree import ElementTree
+
+from .exceptions import odxrequire
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkId
+from .snrefcontext import SnRefContext
+
+
+@dataclass(kw_only=True)
+class ReadParamValue:
+    phys_constant_value: str
+
+    # exactly one of the following attributes must be non-None
+    in_param_if_snref: str | None = None
+    in_param_if_snpathref: str | None = None
+
+    semantic: str
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "ReadParamValue":
+        phys_constant_value = odxrequire(et_element.findtext("PHYS-CONSTANT-VALUE"))
+
+        in_param_if_snref = None
+        if (in_param_if_snref_elem := et_element.find("IN-PARAM-IF-SNREF")) is not None:
+            in_param_if_snref = odxrequire(in_param_if_snref_elem.attrib.get("SHORT-NAME"))
+
+        in_param_if_snpathref = None
+        if (in_param_if_snpathref_elem := et_element.find("IN-PARAM-IF-SNPATHREF")) is not None:
+            in_param_if_snpathref = odxrequire(
+                in_param_if_snpathref_elem.attrib.get("SHORT-NAME-PATH"))
+
+        semantic = odxrequire(et_element.attrib.get("SEMANTIC"))
+
+        return ReadParamValue(
+            phys_constant_value=phys_constant_value,
+            in_param_if_snref=in_param_if_snref,
+            in_param_if_snpathref=in_param_if_snpathref,
+            semantic=semantic,
+        )
+
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
+        odxlinks: dict[OdxLinkId, Any] = {}
+        return odxlinks
+
+    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
+        pass
+
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
+        pass

odxtools/request.py

@@ -113,8 +113,8 @@ class Request(IdentifiableElement):
 
         return encode_state.coded_message
 
-    def decode(self, message: bytes) -> ParameterValueDict:
-        decode_state = DecodeState(coded_message=message)
+    def decode(self, message: bytes | bytearray) -> ParameterValueDict:
+        decode_state = DecodeState(coded_message=bytes(message))
         param_values = self.decode_from_pdu(decode_state)
 
         if not isinstance(param_values, dict):
@@ -129,5 +129,5 @@ class Request(IdentifiableElement):
     def decode_from_pdu(self, decode_state: DecodeState) -> ParameterValue:
         return composite_codec_decode_from_pdu(self, decode_state)
 
-    def coded_const_prefix(self, request_prefix: bytes = b'') -> bytes:
+    def coded_const_prefix(self, request_prefix: bytes = b'') -> bytearray:
         return composite_codec_get_coded_const_prefix(self, request_prefix)

odxtools/response.py

@@ -109,14 +109,18 @@ class Response(IdentifiableElement):
         context.response = None
         context.parameters = None
 
-    def encode(self, coded_request: bytes | None = None, **kwargs: ParameterValue) -> bytearray:
-        encode_state = EncodeState(triggering_request=coded_request, is_end_of_pdu=True)
+    def encode(self,
+               coded_request: bytes | bytearray | None = None,
+               **kwargs: ParameterValue) -> bytearray:
+        encode_state = EncodeState(
+            triggering_request=bytes(coded_request) if coded_request is not None else None,
+            is_end_of_pdu=True)
 
         self.encode_into_pdu(physical_value=kwargs, encode_state=encode_state)
 
         return encode_state.coded_message
 
-    def decode(self, message: bytes) -> ParameterValueDict:
+    def decode(self, message: bytes | bytearray) -> ParameterValueDict:
         decode_state = DecodeState(coded_message=message)
         param_values = self.decode_from_pdu(decode_state)
 
@@ -151,5 +155,5 @@ class Response(IdentifiableElement):
 
         print(parameter_info(self.free_parameters), end="")
 
-    def coded_const_prefix(self, request_prefix: bytes = b'') -> bytes:
+    def coded_const_prefix(self, request_prefix: bytes = b'') -> bytearray:
         return composite_codec_get_coded_const_prefix(self, request_prefix)

odxtools/statemachine.py

@@ -97,8 +97,9 @@ class StateMachine:
         self._state_chart = state_chart
         self._active_state = state_chart.start_state
 
-    def execute(self, service: "DiagService", **service_params: Any
-               ) -> Generator[bytes, bytes | bytearray | ParameterValueDict, None]:
+    def execute(
+        self, service: "DiagService", **service_params: Any
+    ) -> Generator[bytes | bytearray, bytes | bytearray | ParameterValueDict, None]:
         """Run a diagnostic service and update the state machine
         depending on the outcome.
 

odxtools/subcomponentparamconnector.py

@@ -77,7 +77,7 @@ class SubComponentParamConnector(IdentifiableElement):
                                 odxrequire(context.diag_layer).diag_comms, DiagService)
         self._service = service
 
-        if self._service.request is not None:
+        if self._service.request is None:
             odxraise()
             return
         if not self._service.positive_responses:

odxtools/systemitem.py

@@ -0,0 +1,23 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass
+from xml.etree import ElementTree
+
+from .configitem import ConfigItem
+from .exceptions import odxrequire
+from .odxdoccontext import OdxDocContext
+from .utils import dataclass_fields_asdict
+
+
+@dataclass(kw_only=True)
+class SystemItem(ConfigItem):
+    """This class represents a SYSTEM-ITEM."""
+
+    sysparam: str
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "SystemItem":
+        kwargs = dataclass_fields_asdict(ConfigItem.from_et(et_element, context))
+
+        sysparam = odxrequire(et_element.attrib.get("SYSPARAM"))
+
+        return SystemItem(sysparam=sysparam, **kwargs)

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

@@ -1,6 +1,10 @@
 {#- -*- mode: sgml; tab-width: 1; indent-tabs-mode: nil -*-
  #
  # SPDX-License-Identifier: MIT
+ #
+ # This template writes an .odx-d file containing a diag layer container, i.e.,
+ # a collection of descriptions of the diagnostic interactions which are
+ # supported by variants of ECUs.
 -#}
 {%- import('macros/printOdxCategory.xml.jinja2') as poc %}
 {%- import('macros/printEcuSharedData.xml.jinja2') as pecusd -%}

odxtools/templates/ecu_config.odx-e.xml.jinja2

@@ -0,0 +1,38 @@
+{#- -*- mode: sgml; tab-width: 1; indent-tabs-mode: nil -*-
+ #
+ # SPDX-License-Identifier: MIT
+ #
+ # This template writes an .odx-e file containing an ECU-CONFIG description
+ # for variant coding.
+-#}
+{%- import('macros/printOdxCategory.xml.jinja2') as poc %}
+{%- import('macros/printConfigData.xml.jinja2') as pcd %}
+{%- import('macros/printConfigDataDictionarySpec.xml.jinja2') as pcdds %}
+{%- import('macros/printAudience.xml.jinja2') as paud %}
+{#- -#}
+
+<?xml version="1.0" encoding="UTF-8" standalone="no" ?>
+<!-- Written using odxtools {{odxtools_version}} -->
+<ODX MODEL-VERSION="2.2.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="odx.xsd">
+  {{- set_category_docfrag(ecu_config.short_name, "ECU-CONFIG") }}
+  <ECU-CONFIG {{- poc.printOdxCategoryAttribs(ecu_config) }}>
+    {{- poc.printOdxCategorySubtags(ecu_config)|indent(4) }}
+    {%- if ecu_config.config_datas %}
+    <CONFIG-DATAS>
+      {%- for config_data in ecu_config.config_datas %}
+      {{ pcd.printConfigData(config_data) | indent(6) }}
+      {%- endfor %}
+    </CONFIG-DATAS>
+    {%- endif %}
+    {%- if ecu_config.additional_audiences %}
+    <ADDITIONAL-AUDIENCES>
+      {%- for additional_audience in ecu_config.additional_audiences %}
+      {{ paud.printAdditionalAudience(additional_audience) | indent(6) }}
+      {%- endfor %}
+    </ADDITIONAL-AUDIENCES>
+    {%- endif %}
+    {%- if ecu_config.config_data_dictionary_spec %}
+    {{ pcdds.printConfigDataDictionarySpec(ecu_config.config_data_dictionary_spec) | indent(4) }}
+    {%- endif %}
+  </ECU-CONFIG>
+</ODX>

odxtools/templates/flash.odx-f.xml.jinja2

@@ -2,8 +2,8 @@
  #
  # SPDX-License-Identifier: MIT
  #
- # This template writes an .odx-cs file for a communication
- # parameter subset.
+ # This template writes an .odx-f file containing descriptions of firmware
+ # blobs that can be flashed to ECUs.
 -#}
 {%- import('macros/printOdxCategory.xml.jinja2') as poc %}
 {%- import('macros/printEcuMem.xml.jinja2') as pem %}

odxtools/templates/macros/printAudience.xml.jinja2

@@ -11,8 +11,8 @@
 </ADDITIONAL-AUDIENCE>
 {%- endmacro -%}
 
-{%- macro printAudience(audience) -%}
-<AUDIENCE {{-make_bool_xml_attrib("IS-SUPPLIER", audience.is_supplier_raw)}}
+{%- macro printAudience(audience, tag_name="AUDIENCE") -%}
+<{{tag_name}} {{-make_bool_xml_attrib("IS-SUPPLIER", audience.is_supplier_raw)}}
           {{-make_bool_xml_attrib("IS-DEVELOPMENT", audience.is_development_raw)}}
           {{-make_bool_xml_attrib("IS-MANUFACTURING", audience.is_manufacturing_raw)}}
           {{-make_bool_xml_attrib("IS-AFTERSALES", audience.is_aftersales_raw)}}
@@ -31,5 +31,5 @@
 {%- endfor %}
  </DISABLED-AUDIENCE-REFS>
 {%- endif%}
-</AUDIENCE>
+</{{tag_name}}>
 {%- endmacro -%}

odxtools/templates/macros/printChecksum.xml.jinja2

@@ -31,6 +31,6 @@
     {%- if checksum.checksum_result.value_type is not none %}
     {#- #} TYPE="{{ checksum.checksum_result.value_type.value }}"
     {%- endif %}
-    {#- #}>{{checksum.checksum_result.value}}</CHECKSUM-RESULT>
+    {#- #}>{{checksum.checksum_result.value_raw}}</CHECKSUM-RESULT>
 </CHECKSUM>
 {%- endmacro -%}

odxtools/templates/macros/printCompuMethod.xml.jinja2

@@ -110,7 +110,7 @@
 </PROG-CODE>
 {%- endmacro -%}
 
-{%- macro printCompuMethod(cm) -%}
+{%- macro printCompuMethod(cm) %}
 <COMPU-METHOD>
  <CATEGORY>{{cm.category.value}}</CATEGORY>
  {%- if cm.compu_internal_to_phys is not none %}
@@ -144,4 +144,4 @@
  </COMPU-PHYS-TO-INTERNAL>
  {%- endif %}
 </COMPU-METHOD>
-{%- endmacro -%}
+{%- endmacro %}