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

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) }}>

odxtools/templates/macros/printDataRecord.xml.jinja2

@@ -0,0 +1,35 @@
+1{#- -*- mode: sgml; tab-width: 1; indent-tabs-mode: nil -*-
+ #
+ # SPDX-License-Identifier: MIT
+-#}
+
+{%- import('macros/printElementId.xml.jinja2') as peid %}
+{%- import('macros/printSpecialData.xml.jinja2') as psd %}
+
+{%- macro printDataRecord(data_record) -%}
+<DATA-RECORD {{ make_xml_attrib("DATAFORMAT", data_record.dataformat.value) }}>
+  {{peid.printElementIdSubtags(data_record)|indent(2) }}
+  {%- if data_record.rule is not none %}
+  <RULE>{{data_record.rule | e}}</RULE>
+  {%- endif %}
+  {%- if data_record.key is not none %}
+  <KEY>{{data_record.key | e}}</KEY>
+  {%- endif %}
+  {%- if data_record.data_id is not none %}
+  <DATA-ID
+    {%- if data_record.data_id.value_type is not none %}
+      {#- #} TYPE="{{ data_record.data_id.value_type.value }}"
+      {%- endif %}
+      {#- #}>{{data_record.data_id.value_raw | e}}</DATA-ID>
+  {%- endif %}
+  {{- psd.printSpecialDataGroups(data_record.sdgs)|indent(2, first=True) }}{#- #}
+  {%- if data_record.datafile is not none %}
+  <DATAFILE {{ make_bool_xml_attrib("LATEBOUND-DATAFILE", data_record.datafile.latebound_datafile) }}>
+    {#- #}{{data_record.datafile.value | e}}
+  {#- #}</DATAFILE>
+  {%- endif %}
+  {%- if data_record.data is defined %}
+  <DATA>{{data_record.data | e}}</DATA>
+  {%- endif %}
+</DATA-RECORD>
+{%- endmacro -%}

odxtools/templates/macros/printDiagCommDataConnector.xml.jinja2

@@ -0,0 +1,66 @@
+1{#- -*- mode: sgml; tab-width: 1; indent-tabs-mode: nil -*-
+ #
+ # SPDX-License-Identifier: MIT
+-#}
+
+{%- import('macros/printAdminData.xml.jinja2') as pad %}
+{%- import('macros/printElementId.xml.jinja2') as peid %}
+{%- import('macros/printConfigItems.xml.jinja2') as pcits %}
+{%- import('macros/printSpecialData.xml.jinja2') as psd %}
+
+{%- macro printDiagCommDataConnector(connector) -%}
+<DIAG-COMM-DATA-CONNECTOR>
+  <UNCOMPRESSED-SIZE>{{connector.uncompressed_size}}</UNCOMPRESSED-SIZE>
+  {%- set num_nibbles = (connector.source_start_address.bit_length() + 7) // 8 * 2 %}
+  <SOURCE-START-ADDRESS>{{ ("%%0%dX" | format(num_nibbles | int)) | format(connector.source_start_address | int) }}</SOURCE-START-ADDRESS>
+  {%- if connector.read_diag_comm_connector is not none %}
+  {%- set rdcc = connector.read_diag_comm_connector %}
+  <READ-DIAG-COMM-CONNECTOR>
+    {%- if rdcc.read_param_values %}
+    <READ-PARAM-VALUES>
+       {%- for rpv in rdcc.read_param_values %}
+       <READ-PARAM-VALUE {{ make_xml_attrib("SEMANTIC", rpv.semantic) }}>
+         <PHYS-CONSTANT-VALUE>{{ rpv.phys_constant_value | e }}</PHYS-CONSTANT-VALUE>
+         {%- if rpv.in_param_if_snref is not none %}
+         <IN-PARAM-IF-SNREF SHORT-NAME="{{rpv.in_param_if_snref}}" />
+         {%- endif %}
+         {%- if rpv.in_param_if_snpathref is not none %}
+         <IN-PARAM-IF-SNPATHREF SHORT-NAME-PATH="{{rpv.in_param_if_snpathref}}" />
+         {%- endif %}
+       </READ-PARAM-VALUE>
+       {%- endfor %}
+    </READ-PARAM-VALUES>
+    {%- endif %}
+    {%- if rdcc.read_diag_comm_ref is not none %}
+    <READ-DIAG-COMM-REF {{make_ref_attribs(rdcc.read_diag_comm_ref)}} />
+    {%- endif %}
+    {%- if rdcc.read_diag_comm_snref is not none %}
+    <READ-DIAG-COMM-SNREF SHORT-NAME="{{rdcc.read_diag_comm_snref}}" />
+    {%- endif %}
+    {%- if rdcc.read_data_snref is not none %}
+    <READ-DATA-SNREF SHORT-NAME="{{rdcc.read_data_snref}}" />
+    {%- endif %}
+    {%- if rdcc.read_data_snpathref is not none %}
+    <READ-DATA-SNPATHREF SHORT-NAME-PATH="{{rdcc.read_data_snpathref}}" />
+    {%- endif %}
+  </READ-DIAG-COMM-CONNECTOR>
+  {%- endif %}
+  {%- if connector.write_diag_comm_connector is not none %}
+  {%- set wdcc = connector.write_diag_comm_connector %}
+  <WRITE-DIAG-COMM-CONNECTOR>
+    {%- if wdcc.write_diag_comm_ref is not none %}
+    <WRITE-DIAG-COMM-REF {{make_ref_attribs(wdcc.write_diag_comm_ref)}} />
+    {%- endif %}
+    {%- if wdcc.write_diag_comm_snref is not none %}
+    <WRITE-DIAG-COMM-SNREF SHORT-NAME="{{wdcc.write_diag_comm_snref}}" />
+    {%- endif %}
+    {%- if wdcc.write_data_snref is not none %}
+    <WRITE-DATA-SNREF SHORT-NAME="{{wdcc.write_data_snref}}" />
+    {%- endif %}
+    {%- if wdcc.write_data_snpathref is not none %}
+    <WRITE-DATA-SNPATHREF SHORT-NAME-PATH="{{wdcc.write_data_snpathref}}" />
+    {%- endif %}
+  </WRITE-DIAG-COMM-CONNECTOR>
+  {%- endif %}
+</DIAG-COMM-DATA-CONNECTOR>
+{%- endmacro -%}

odxtools/templates/macros/printExpectedIdent.xml.jinja2

@@ -14,7 +14,7 @@
       {%- if ident_value.value_type is not none %}
       {#- #} TYPE="{{ ident_value.value_type.value }}"
       {%- endif %}
-      {#- #}>{{ident_value.value}}</IDENT-VALUE>
+      {#- #}>{{ident_value.value_raw}}</IDENT-VALUE>
     {%- endfor %}
   </IDENT-VALUES>
 </EXPECTED-IDENT>

odxtools/templates/macros/printFlashdata.xml.jinja2

@@ -30,10 +30,10 @@
     {%- if flashdata.encrypt_compress_method.value_type is not none %}
     {#- #} TYPE="{{ flashdata.encrypt_compress_method.value_type.value }}"
     {%- endif %}
-    {#- #}>{{flashdata.encrypt_compress_method.value}}</ENCRYPT-COMPRESS-METHOD>
+    {#- #}>{{flashdata.encrypt_compress_method.value_raw}}</ENCRYPT-COMPRESS-METHOD>
   {%- endif %}
   {%- if flashdata.datafile is defined %}
-  <DATAFILE {{ make_bool_xml_attrib("LATEBOUND-DATAFILE", flashdata.latebound_datafile) }}>
+  <DATAFILE {{ make_bool_xml_attrib("LATEBOUND-DATAFILE", flashdata.datafile.latebound_datafile) }}>
     {#- #}{{flashdata.datafile.value}}
   {#- #}</DATAFILE>
   {%- elif flashdata.data is defined %}

odxtools/templates/macros/printItemValue.xml.jinja2

@@ -0,0 +1,31 @@
+1{#- -*- mode: sgml; tab-width: 1; indent-tabs-mode: nil -*-
+ #
+ # SPDX-License-Identifier: MIT
+-#}
+
+{%- import('macros/printAudience.xml.jinja2') as paud %}
+{%- import('macros/printSpecialData.xml.jinja2') as psd %}
+
+{%- macro printItemValue(item_value) -%}
+<ITEM-VALUE>
+  {%- if item_value.phys_constant_value is not none %}
+  <PHYS-CONSTANT-VALUE>{{item_value.phys_constant_value | e}}</PHYS-CONSTANT-VALUE>
+  {%- endif %}
+  {%- if item_value.meaning is not none %}
+  <MEANING {{- make_xml_attrib("TI", item_value.meaning.text_identifier) }}>{{item_value.meaning|e}}</MEANING>
+  {%- endif %}
+  {%- if item_value.key is not none %}
+  <KEY>{{item_value.key | e}}</KEY>
+  {%- endif %}
+  {%- if item_value.rule is not none %}
+  <RULE>{{item_value.rule | e}}</RULE>
+  {%- endif %}
+  {%- if item_value.description is not none %}
+  <DESCRIPTION {{- make_xml_attrib("TI", item_value.description.text_identifier) }}>{{item_value.description|e}}</DESCRIPTION>
+  {%- endif %}
+  {{- psd.printSpecialDataGroups(item_value.sdgs)|indent(2, first=True) }}{#- #}
+  {%- if item_value.audience is not none %}
+  {{ paud.printAudience(item_value.audience) | indent(2) }}
+  {%- endif %}
+</ITEM-VALUE>
+{%- endmacro -%}

odxtools/templates/macros/printOwnIdent.xml.jinja2

@@ -12,6 +12,6 @@
     {%- if own_ident.ident_value.value_type is not none %}
     {#- #} TYPE="{{ own_ident.ident_value.value_type.value }}"
     {%- endif %}
-    {#- #}>{{own_ident.ident_value.value}}</IDENT-VALUE>
+    {#- #}>{{own_ident.ident_value.value_raw}}</IDENT-VALUE>
 </OWN-IDENT>
 {%- endmacro -%}

odxtools/templates/macros/printSecurity.xml.jinja2

@@ -10,28 +10,28 @@
     {%- if security.security_method.value_type is not none %}
     {#- #} TYPE="{{ security.security_method.value_type.value }}"
     {%- endif %}
-    {#- #}>{{security.security_method.value}}</SECURITY-METHOD>
+    {#- #}>{{security.security_method.value_raw}}</SECURITY-METHOD>
   {%- endif %}
   {%- if security.fw_signature is not none %}
   <FW-SIGNATURE
     {%- if security.fw_signature.value_type is not none %}
     {#- #} TYPE="{{ security.fw_signature.value_type.value }}"
     {%- endif %}
-    {#- #}>{{security.fw_signature.value}}</FW-SIGNATURE>
+    {#- #}>{{security.fw_signature.value_raw}}</FW-SIGNATURE>
   {%- endif %}
   {%- if security.fw_checksum is not none %}
   <FW-CHECKSUM
     {%- if security.fw_checksum.value_type is not none %}
     {#- #} TYPE="{{ security.fw_checksum.value_type.value }}"
     {%- endif %}
-    {#- #}>{{security.fw_checksum.value}}</FW-CHECKSUM>
+    {#- #}>{{security.fw_checksum.value_raw}}</FW-CHECKSUM>
   {%- endif %}
   {%- if security.validity_for is not none %}
   <VALIDITY-FOR
     {%- if security.validity_for.value_type is not none %}
     {#- #} TYPE="{{ security.validity_for.value_type.value }}"
     {%- endif %}
-    {#- #}>{{security.validity_for.value}}</VALIDITY-FOR>
+    {#- #}>{{security.validity_for.value_raw}}</VALIDITY-FOR>
   {%- endif %}
 </SECURITY>
 {%- endmacro -%}

odxtools/templates/macros/printSegment.xml.jinja2

@@ -25,7 +25,7 @@
     {%- if segment.encrypt_compress_method.value_type is not none %}
     {#- #} TYPE="{{ segment.encrypt_compress_method.value_type.value }}"
     {%- endif %}
-    {#- #}>{{segment.encrypt_compress_method.value}}</ENCRYPT-COMPRESS-METHOD>
+    {#- #}>{{segment.encrypt_compress_method.value_raw | e}}</ENCRYPT-COMPRESS-METHOD>
   {%- endif %}
 </SEGMENT>
 {%- endmacro -%}

odxtools/validbasevariant.py

@@ -0,0 +1,62 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass
+from itertools import chain
+from typing import Any
+from xml.etree import ElementTree
+
+from .diaglayers.basevariant import BaseVariant
+from .diaglayers.ecuvariant import EcuVariant
+from .exceptions import odxrequire
+from .nameditemlist import NamedItemList
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkId, resolve_snref
+from .snrefcontext import SnRefContext
+
+
+@dataclass(kw_only=True)
+class ValidBaseVariant:
+    ecu_variant_snrefs: list[str]
+    base_variant_snref: str
+
+    @property
+    def ecu_variants(self) -> NamedItemList[EcuVariant]:
+        return self._ecu_variants
+
+    @property
+    def base_variant(self) -> BaseVariant:
+        return self._base_variant
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "ValidBaseVariant":
+        ecu_variant_snrefs = []
+        for ecuv_snref_elem in et_element.iterfind("ECU-VARIANT-SNREFS/ECU-VARIANT-SNREF"):
+            ecu_variant_snrefs.append(odxrequire(ecuv_snref_elem.attrib["SHORT-NAME"]))
+
+        basev_snref_elem = odxrequire(et_element.find("BASE-VARIANT-SNREF"))
+        base_variant_snref = odxrequire(basev_snref_elem.attrib["SHORT-NAME"])
+
+        return ValidBaseVariant(
+            ecu_variant_snrefs=ecu_variant_snrefs, base_variant_snref=base_variant_snref)
+
+    def __post_init__(self) -> None:
+        self._ecu_variants: NamedItemList[EcuVariant]
+        self._base_variant: BaseVariant
+
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
+        result: dict[OdxLinkId, Any] = {}
+        return result
+
+    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
+        pass
+
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
+        db = odxrequire(context.database)
+
+        ecu_variants = chain(*[dlc.ecu_variants for dlc in db.diag_layer_containers])
+        base_variants = chain(*[dlc.base_variants for dlc in db.diag_layer_containers])
+
+        self._ecu_variants = NamedItemList[EcuVariant]()
+        for ev_snref in self.ecu_variant_snrefs:
+            self._ecu_variants.append(resolve_snref(ev_snref, ecu_variants, EcuVariant))
+
+        self._base_variant = resolve_snref(self.base_variant_snref, base_variants, BaseVariant)

odxtools/validityfor.py

@@ -5,17 +5,26 @@ from xml.etree import ElementTree
 
 from .exceptions import odxraise, odxrequire
 from .odxdoccontext import OdxDocContext
+from .odxtypes import AtomicOdxType, DataType
 from .sessionsubelemtype import SessionSubElemType
 
 
 @dataclass(kw_only=True)
 class ValidityFor:
-    value: str
+    value_raw: str
     value_type: SessionSubElemType
 
+    @property
+    def value(self) -> AtomicOdxType:
+        return self._value
+
+    @property
+    def data_type(self) -> DataType:
+        return self._data_type
+
     @staticmethod
     def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "ValidityFor":
-        value = et_element.text or ""
+        value_raw = et_element.text or ""
 
         value_type_str = odxrequire(et_element.get("TYPE"))
         try:
@@ -25,6 +34,10 @@ class ValidityFor:
             odxraise(f"Encountered unknown SESSION-SUB-ELEM-TYPE type '{value_type_str}'")
 
         return ValidityFor(
-            value=value,
+            value_raw=value_raw,
             value_type=value_type,
         )
+
+    def __post_init__(self) -> None:
+        self._data_type = DataType(self.value_type.value)
+        self._value = self._data_type.from_string(self.value_raw.strip())

odxtools/variantmatcher.py

@@ -107,14 +107,14 @@ class VariantMatcher:
                     req_bytes = matching_param.get_ident_service(variant).encode_request()
 
                     if self.use_cache and req_bytes in self.req_resp_cache:
-                        resp_values = copy(self.req_resp_cache[req_bytes])
+                        resp_values = copy(bytes(self.req_resp_cache[bytes(req_bytes)]))
                     else:
                         if isinstance(matching_param, MatchingBaseVariantParameter):
-                            yield matching_param.use_physical_addressing, req_bytes
+                            yield matching_param.use_physical_addressing, bytes(req_bytes)
                         else:
-                            yield True, req_bytes
+                            yield True, bytes(req_bytes)
                         resp_values = self._get_ident_response()
-                        self._update_cache(req_bytes, copy(resp_values))
+                        self._update_cache(bytes(req_bytes), copy(bytes(resp_values)))
 
                     cur_response_matches = self._ident_response_matches(
                         variant, matching_param, resp_values)

odxtools/version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '10.2.0'
-__version_tuple__ = version_tuple = (10, 2, 0)
+__version__ = version = '10.3.0'
+__version_tuple__ = version_tuple = (10, 3, 0)

odxtools/writediagcommconnector.py

@@ -0,0 +1,77 @@
+# 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, resolve_snref
+from .parameters.valueparameter import ValueParameter
+from .request import Request
+from .snrefcontext import SnRefContext
+
+
+@dataclass(kw_only=True)
+class WriteDiagCommConnector:
+    # exactly one of the following attributes must be non-None
+    write_diag_comm_ref: OdxLinkRef | None = None
+    write_diag_comm_snref: str | None = None
+
+    # exactly one of the following attributes must be non-None
+    write_data_snref: str | None = None
+    write_data_snpathref: str | None = None
+
+    @property
+    def write_diag_comm(self) -> DiagComm | None:
+        return self._write_diag_comm
+
+    @property
+    def write_data(self) -> ValueParameter | None:
+        return self._write_data
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element,
+                context: OdxDocContext) -> "WriteDiagCommConnector":
+        write_diag_comm_ref = OdxLinkRef.from_et(et_element.find("WRITE-DIAG-COMM-REF"), context)
+        write_diag_comm_snref = None
+        if (write_diag_comm_snref_elem := et_element.find("WRITE-DIAG-COMM-SNREF")) is not None:
+            write_diag_comm_snref = odxrequire(write_diag_comm_snref_elem.attrib.get("SHORT-NAME"))
+
+        write_data_snref = None
+        if (write_data_snref_elem := et_element.find("WRITE-DATA-SNREF")) is not None:
+            write_data_snref = odxrequire(write_data_snref_elem.attrib.get("SHORT-NAME"))
+
+        write_data_snpathref = None
+        if (write_data_snpathref_elem := et_element.find("WRITE-DATA-SNPATHREF")) is not None:
+            write_data_snpathref = odxrequire(
+                write_data_snpathref_elem.attrib.get("SHORT-NAME-PATH"))
+
+        return WriteDiagCommConnector(
+            write_diag_comm_ref=write_diag_comm_ref,
+            write_diag_comm_snref=write_diag_comm_snref,
+            write_data_snref=write_data_snref,
+            write_data_snpathref=write_data_snpathref,
+        )
+
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
+        odxlinks: dict[OdxLinkId, Any] = {}
+
+        return odxlinks
+
+    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
+        self._write_diag_comm = None
+        if self.write_diag_comm_ref is not None:
+            self._write_diag_comm = odxlinks.resolve(self.write_diag_comm_ref, DiagComm)
+
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
+        # write_diag_comm_snref can only be uniquely resolved ahead of
+        # time if the diag comm is referenced via ODXLINK, the write
+        # data parameter is referenced via SNREF. If the diag comm is
+        # referenced via SNREF, it depends on the applicable diag layer
+        self._write_data = None
+        if self.write_data_snref is not None and \
+           self._write_diag_comm is not None and \
+           (req := getattr(self._write_diag_comm, "request", None)) is not None:
+            assert isinstance(req, Request)
+            self._write_data = resolve_snref(self.write_data_snref, req.parameters, ValueParameter)