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

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/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 %}

odxtools/templates/macros/printConfigData.xml.jinja2

@@ -0,0 +1,39 @@
+1{#- -*- mode: sgml; tab-width: 1; indent-tabs-mode: nil -*-
+ #
+ # SPDX-License-Identifier: MIT
+-#}
+
+{%- import('macros/printAdminData.xml.jinja2') as pad %}
+{%- import('macros/printConfigRecord.xml.jinja2') as pcr %}
+{%- import('macros/printElementId.xml.jinja2') as peid %}
+{%- import('macros/printSpecialData.xml.jinja2') as psd %}
+
+{%- macro printConfigData(config_data) -%}
+<CONFIG-DATA>
+  {{peid.printElementIdSubtags(config_data)|indent(2) }}
+  {%- if config_data.valid_base_variants %}
+  <VALID-BASE-VARIANTS>
+    {%- for valid_base_variant in config_data.valid_base_variants %}
+    <VALID-BASE-VARIANT>
+      {%- if valid_base_variant.ecu_variant_snrefs %}
+      <ECU-VARIANT-SNREFS>
+        {%- for ecu_variant_snref in valid_base_variant.ecu_variant_snrefs %}
+        <ECU-VARIANT-SNREF SHORT-NAME="{{ecu_variant_snref}}" />
+        {%- endfor %}
+      </ECU-VARIANT-SNREFS>
+      {%- endif %}
+      <BASE-VARIANT-SNREF SHORT-NAME="{{valid_base_variant.base_variant_snref}}" />
+    </VALID-BASE-VARIANT>
+    {%- endfor %}
+  </VALID-BASE-VARIANTS>
+  {%- endif %}
+  {%- if config_data.config_records %}
+  <CONFIG-RECORDS>
+    {%- for config_record in config_data.config_records %}
+    {{ pcr.printConfigRecord(config_record) | indent(4) }}
+    {%- endfor %}
+  </CONFIG-RECORDS>
+  {%- endif %}
+  {{- psd.printSpecialDataGroups(config_data.sdgs)|indent(2, first=True) }}{#- #}
+</CONFIG-DATA>
+{%- endmacro -%}

odxtools/templates/macros/printConfigDataDictionarySpec.xml.jinja2

@@ -0,0 +1,22 @@
+{#- -*- mode: sgml; tab-width: 1; indent-tabs-mode: nil -*-
+ #
+ # SPDX-License-Identifier: MIT
+-#}
+
+{%- import('macros/printDOP.xml.jinja2') as pdop %}
+{%- import('macros/printUnitSpec.xml.jinja2') as punit %}
+
+{%- macro printConfigDataDictionarySpec(cdds) -%}
+<CONFIG-DATA-DICTIONARY-SPEC>
+  {%- if cdds.data_object_props %}
+  <DATA-OBJECT-PROPS>
+    {%- for dop in cdds.data_object_props %}
+    {{- pdop.printDataObjectProp(dop)|indent(3) }}
+    {%- endfor %}
+  </DATA-OBJECT-PROPS>
+  {%- endif %}
+  {%- if cdds.unit_spec %}
+  {{ punit.printUnitSpec(cdds.unit_spec)|indent(2) }}
+  {%- endif %}
+</CONFIG-DATA-DICTIONARY-SPEC>
+{%- endmacro -%}

odxtools/templates/macros/printConfigItems.xml.jinja2

@@ -0,0 +1,66 @@
+1{#- -*- mode: sgml; tab-width: 1; indent-tabs-mode: nil -*-
+ #
+ # SPDX-License-Identifier: MIT
+-#}
+
+{%- import('macros/printAudience.xml.jinja2') as paud %}
+{%- import('macros/printElementId.xml.jinja2') as peid %}
+{%- import('macros/printItemValue.xml.jinja2') as piv %}
+{%- import('macros/printSpecialData.xml.jinja2') as psd %}
+
+{%- macro printConfigItemSubtags(config_item) %}
+{#-#}{{ peid.printElementIdSubtags(config_item) }}
+{%- if config_item.byte_position is not none %}
+<BYTE-POSITION>{{config_item.byte_position}}</BYTE-POSITION>
+{%- endif %}
+{%- if config_item.bit_position is not none %}
+<BIT-POSITION>{{config_item.bit_position}}</BIT-POSITION>
+{%- endif %}
+{%- if config_item.data_object_prop_ref is not none %}
+<DATA-OBJECT-PROP-REF {{ make_ref_attribs(config_item.data_object_prop_ref) }} />
+{%- endif %}
+{%- if config_item.data_object_prop_snref is not none %}
+<DATA-OBJECT-PROP-SNREF SHORT-NAME="{{ config_item.data_object_prop_snref }}" />
+{%- endif %}
+{{- psd.printSpecialDataGroups(config_item.sdgs) }}
+{%- endmacro %}
+
+{%- macro printConfigIdItem(config_id_item) %}
+<CONFIG-ID-ITEM>
+  {{ printConfigItemSubtags(config_id_item)|indent(2) }}
+</CONFIG-ID-ITEM>
+{%- endmacro %}
+
+{%- macro printDataIdItem(data_id_item) %}
+<DATA-ID-ITEM>
+  {{ printConfigItemSubtags(data_id_item)|indent(2) }}
+</DATA-ID-ITEM>
+{%- endmacro %}
+
+{%- macro printOptionItem(option_item) %}
+<OPTION-ITEM>
+  {{ printConfigItemSubtags(option_item)|indent(2) }}
+  {%- if option_item.physical_default_value is not none %}
+  <PHYSICAL-DEFAULT-VALUE>{{ option_item.physical_default_value|e }}</PHYSICAL-DEFAULT-VALUE>
+  {%- endif %}
+  {%- if option_item.item_values %}
+  <ITEM-VALUES>
+    {%- for item_value in option_item.item_values %}
+    {{ piv.printItemValue(item_value) }}
+    {%- endfor %}
+  </ITEM-VALUES>
+  {%- endif %}
+  {%- if option_item.write_audience is not none %}
+  {{ paud.printAudience(option_item.write_audience, "WRITE-AUDIENCE")}}
+  {%- endif %}
+  {%- if option_item.read_audience is not none %}
+  {{ paud.printAudience(option_item.read_audience, "READ-AUDIENCE")}}
+  {%- endif %}
+</OPTION-ITEM>
+{%- endmacro %}
+
+{%- macro printSystemItem(system_item) %}
+<SYSTEM-ITEM {{ make_xml_attrib("SYSPARAM", system_item.sysparam) }}>
+  {{ printConfigItemSubtags(system_item)|indent(2) }}
+</SYSTEM-ITEM>
+{%- endmacro %}

odxtools/templates/macros/printConfigRecord.xml.jinja2

@@ -0,0 +1,73 @@
+1{#- -*- mode: sgml; tab-width: 1; indent-tabs-mode: nil -*-
+ #
+ # SPDX-License-Identifier: MIT
+-#}
+
+{%- import('macros/printAdminData.xml.jinja2') as pad %}
+{%- import('macros/printAudience.xml.jinja2') as paud %}
+{%- import('macros/printDataRecord.xml.jinja2') as pdr %}
+{%- import('macros/printDiagCommDataConnector.xml.jinja2') as pdcdc %}
+{%- import('macros/printElementId.xml.jinja2') as peid %}
+{%- import('macros/printConfigItems.xml.jinja2') as pcits %}
+{%- import('macros/printSpecialData.xml.jinja2') as psd %}
+
+{%- macro printConfigRecord(config_record) -%}
+<CONFIG-RECORD>
+  {{peid.printElementIdSubtags(config_record)|indent(2) }}
+  {%- if config_record.config_id_item is not none %}
+  {{- pcits.printConfigIdItem(config_record.config_id_item)|indent(2)}}
+  {%- endif %}
+  {%- if config_record.data_items %}
+  <DATA-ITEMS>
+    {%- for data_item in config_record.data_items %}
+    {{ pcits.printDataItem(data_item) | indent(4) }}
+    {%- endfor %}
+  </DATA-ITEMS>
+  {%- endif %}
+  {%- if config_record.diag_comm_data_connectors %}
+  <DIAG-COMM-DATA-CONNECTORS>
+    {%- for connector in config_record.diag_comm_data_connectors %}
+    {{ pdcdc.printDiagCommDataConnector(connector) | indent(4) }}
+    {%- endfor %}
+  </DIAG-COMM-DATA-CONNECTORS>
+  {%- endif %}
+  {%- if config_record.config_id is not none %}
+  <CONFIG-ID
+    {%- if config_record.config_id.value_type is not none %}
+      {#- #} TYPE="{{ config_record.config_id.value_type.value }}"
+      {%- endif %}
+      {#- #}>{{config_record.config_id.value}}</CONFIG-ID>
+  {%- endif %}
+  {%- if config_record.data_records %}
+  <DATA-RECORDS>
+    {%- for data_record in config_record.data_records %}
+    {{ pdr.printDataRecord(data_record) | indent(4) }}
+    {%- endfor %}
+  </DATA-RECORDS>
+  {%- endif %}
+  {%- if config_record.audience is not none %}
+  {{ paud.printAudience(config_record.audience) | indent(2) }}
+  {%- endif %}
+  {%- if config_record.system_items %}
+  <SYSTEM-ITEMS>
+    {%- for system_item in config_record.system_items %}
+    {{- pcits.printSystemItem(system_item) | indent(4) }}
+    {%- endfor %}
+  </SYSTEM-ITEMS>
+  {%- endif %}
+  {%- if config_record.data_id_item is not none %}
+  {{- pcits.printDataIdItem(config_record.data_id_item)|indent(2)}}
+  {%- endif %}
+  {%- if config_record.option_items %}
+  <OPTION-ITEMS>
+    {%- for option_item in config_record.option_items %}
+    {{- pcits.printOptionItem(option_item) | indent(4) }}
+    {%- endfor %}
+  </OPTION-ITEMS>
+  {%- endif %}
+  {%- if config_record.default_data_record_snref is not none %}
+  <DEFAULT-DATA-RECORD-SNREF SHORT-NAME="{{config_record.default_data_record_snref}}" />
+  {%- endif %}
+  {{- psd.printSpecialDataGroups(config_record.sdgs)|indent(2, first=True) }}{#- #}
+</CONFIG-RECORD>
+{%- endmacro -%}

odxtools/templates/macros/printDOP.xml.jinja2

@@ -10,7 +10,7 @@
 {%- import('macros/printDescription.xml.jinja2') as pd %}
 
 
-{%- macro printDiagCodedType(dct) -%}
+{%- macro printDiagCodedType(dct) %}
 <DIAG-CODED-TYPE {{-make_xml_attrib("BASE-DATA-TYPE", dct.base_data_type.value)}}
                  {{-make_xml_attrib("BASE-TYPE-ENCODING", dct.base_type_encoding and dct.base_type_encoding.value)}}
                  {{-make_bool_xml_attrib("IS-HIGHLOW-BYTE-ORDER", dct.is_highlow_byte_order_raw)}}
@@ -34,7 +34,7 @@
  <MIN-LENGTH>{{dct.min_length}}</MIN-LENGTH>
  {%- endif %}
 </DIAG-CODED-TYPE>
-{%- endmacro -%}
+{%- endmacro %}
 
 {%- macro printPhysicalType(physical_type) %}
 {%- if physical_type.display_radix is not none %}
@@ -84,7 +84,6 @@
 {%- macro printDopBaseAttribs(dop) %}
 {{- make_xml_attrib("ID", dop.odx_id.local_id) }}
 {{- make_xml_attrib("OID", dop.oid) }}
-{#- -#}
 {%- endmacro %}
 
 {%- macro printDopBaseSubtags(dop) %}
@@ -92,8 +91,8 @@
  {%- if dop.admin_data %}
  {{ pad.printAdminData(dop.admin_data)|indent(1) }}
  {%- endif %}
- {{ psd.printSpecialDataGroups(dop.sdgs)|indent(1) }}
-{%- endmacro -%}
+ {{- psd.printSpecialDataGroups(dop.sdgs)|indent(1) }}
+{%- endmacro %}
 
 {%- macro printComplexDopAttribs(st) %}
  {{- printDopBaseAttribs(st) }}
@@ -101,7 +100,7 @@
 
 {%- macro printComplexDopSubtags(st) %}
  {{- printDopBaseSubtags(st) }}
-{%- endmacro -%}
+{%- endmacro %}
 
 {%- macro printDataObjectProp(dop) %}
 <DATA-OBJECT-PROP {{- printDopBaseAttribs(dop) }}>