odxtools 7.0.0__py3-none-any.whl → 7.1.1__py3-none-any.whl

odxtools/odxlink.py

@@ -1,10 +1,11 @@
 # SPDX-License-Identifier: MIT
 import warnings
 from dataclasses import dataclass
-from typing import Any, Dict, List, Optional, Type, TypeVar, overload
+from typing import Any, Dict, Iterable, List, Optional, Type, TypeVar, overload
 from xml.etree import ElementTree
 
-from .exceptions import OdxWarning, odxassert
+from .exceptions import OdxWarning, odxassert, odxraise
+from .nameditemlist import OdxNamed, TNamed
 
 
 @dataclass(frozen=True)
@@ -210,8 +211,10 @@ class OdxLinkDatabase:
 
                 return obj
 
-        raise KeyError(f"ODXLINK reference {ref} could not be resolved for any "
-                       f"of the document fragments {ref.ref_docs}")
+        odxraise(
+            f"ODXLINK reference {ref} could not be resolved for any "
+            f"of the document fragments {ref.ref_docs}", KeyError)
+        return None
 
     @overload
     def resolve_lenient(self, ref: OdxLinkRef, expected_type: None = None) -> Any:
@@ -270,3 +273,34 @@ class OdxLinkDatabase:
                     self._db[doc_frag] = {}
 
                 self._db[doc_frag][odx_id] = obj
+
+
+@overload
+def resolve_snref(target_short_name: str,
+                  items: Iterable[OdxNamed],
+                  expected_type: None = None) -> Any:
+    """Resolve a short name reference given a sequence of candidate objects"""
+    ...
+
+
+@overload
+def resolve_snref(target_short_name: str, items: Iterable[OdxNamed],
+                  expected_type: Type[TNamed]) -> TNamed:
+    ...
+
+
+def resolve_snref(target_short_name: str,
+                  items: Iterable[OdxNamed],
+                  expected_type: Any = None) -> Any:
+    candidates = [x for x in items if x.short_name == target_short_name]
+
+    if not candidates:
+        odxraise(f"Cannot resolve short name reference to '{target_short_name}'")
+        return None
+    elif len(candidates) > 1:
+        odxraise(f"Cannot uniquely resolve short name reference to '{target_short_name}'")
+    elif expected_type is not None and not isinstance(candidates[0], expected_type):
+        odxraise(f"Reference '{target_short_name}' points to a {type(candidates[0]).__name__}"
+                 f"object while expecting {expected_type.__name__}")
+
+    return candidates[0]

odxtools/odxtypes.py

@@ -1,6 +1,7 @@
 # SPDX-License-Identifier: MIT
 from enum import Enum
-from typing import TYPE_CHECKING, Any, Callable, Dict, List, Optional, Tuple, Type, Union, overload
+from typing import (TYPE_CHECKING, Any, Callable, Dict, Iterable, Optional, Tuple, Type, Union,
+                    overload)
 from xml.etree import ElementTree
 
 from .exceptions import odxassert, odxraise, odxrequire
@@ -28,7 +29,7 @@ ParameterDict = Dict[str, Union["Parameter", "ParameterDict"]]
 # multiple items, so this can be a list of objects.
 TableStructParameterValue = Tuple[str, "ParameterValue"]
 ParameterValue = Union[AtomicOdxType, "ParameterValueDict", TableStructParameterValue,
-                       List["ParameterValue"], "DiagnosticTroubleCode"]
+                       Iterable["ParameterValue"], "DiagnosticTroubleCode"]
 ParameterValueDict = Dict[str, ParameterValue]
 
 

odxtools/parameters/codedconstparameter.py

@@ -59,8 +59,9 @@ class CodedConstParameter(Parameter):
         super()._resolve_odxlinks(odxlinks)
 
     @override
-    def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
-        super()._resolve_snrefs(diag_layer)
+    def _parameter_resolve_snrefs(self, diag_layer: "DiagLayer", *,
+                                  param_list: List[Parameter]) -> None:
+        super()._parameter_resolve_snrefs(diag_layer, param_list=param_list)
 
     @override
     def get_static_bit_length(self) -> Optional[int]:

odxtools/parameters/lengthkeyparameter.py

@@ -11,7 +11,7 @@ from ..exceptions import EncodeError, odxraise, odxrequire
 from ..odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
 from ..odxtypes import ParameterValue
 from ..utils import dataclass_fields_asdict
-from .parameter import ParameterType
+from .parameter import Parameter, ParameterType
 from .parameterwithdop import ParameterWithDOP
 
 if TYPE_CHECKING:
@@ -60,8 +60,9 @@ class LengthKeyParameter(ParameterWithDOP):
         super()._resolve_odxlinks(odxlinks)
 
     @override
-    def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
-        super()._resolve_snrefs(diag_layer)
+    def _parameter_resolve_snrefs(self, diag_layer: "DiagLayer", *,
+                                  param_list: List[Parameter]) -> None:
+        super()._parameter_resolve_snrefs(diag_layer, param_list=param_list)
 
     @property
     @override

odxtools/parameters/nrcconstparameter.py

@@ -75,8 +75,9 @@ class NrcConstParameter(Parameter):
         super()._resolve_odxlinks(odxlinks)
 
     @override
-    def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
-        super()._resolve_snrefs(diag_layer)
+    def _parameter_resolve_snrefs(self, diag_layer: "DiagLayer", *,
+                                  param_list: List[Parameter]) -> None:
+        super()._parameter_resolve_snrefs(diag_layer, param_list=param_list)
 
     @override
     def get_static_bit_length(self) -> Optional[int]:

odxtools/parameters/parameter.py

@@ -82,7 +82,13 @@ class Parameter(NamedElement):
         for sdg in self.sdgs:
             sdg._resolve_odxlinks(odxlinks)
 
+    @final
     def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
+        raise RuntimeError("Calling _resolve_snrefs() is not allowed for parameters. "
+                           "Use _parameter_resolve_snrefs() instead.")
+
+    def _parameter_resolve_snrefs(self, diag_layer: "DiagLayer", *,
+                                  param_list: List["Parameter"]) -> None:
         for sdg in self.sdgs:
             sdg._resolve_snrefs(diag_layer)
 

odxtools/parameters/parameterwithdop.py

@@ -11,7 +11,7 @@ from ..dopbase import DopBase
 from ..dtcdop import DtcDop
 from ..encodestate import EncodeState
 from ..exceptions import odxassert, odxrequire
-from ..odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef
+from ..odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef, resolve_snref
 from ..odxtypes import AtomicOdxType, ParameterValue
 from ..physicaltype import PhysicalType
 from ..utils import dataclass_fields_asdict
@@ -43,7 +43,7 @@ class ParameterWithDOP(Parameter):
     def __post_init__(self) -> None:
         odxassert(self.dop_snref is not None or self.dop_ref is not None,
                   f"Param {self.short_name} without a DOP-(SN)REF should not exist!")
-        self._dop: Optional[DopBase] = None
+        self._dop: DopBase
 
     @override
     def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
@@ -55,26 +55,22 @@ class ParameterWithDOP(Parameter):
 
         if self.dop_ref is not None:
             odxassert(self.dop_snref is None)
-            # TODO: do not do lenient resolves here. The problem is
-            # that currently not all kinds of DOPs are internalized
-            # (e.g., static and dynamic fields)
-            self._dop = odxlinks.resolve_lenient(self.dop_ref)
+            self._dop = odxlinks.resolve(self.dop_ref)
 
     @override
-    def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
-        super()._resolve_snrefs(diag_layer)
+    def _parameter_resolve_snrefs(self, diag_layer: "DiagLayer", *,
+                                  param_list: List[Parameter]) -> None:
+        super()._parameter_resolve_snrefs(diag_layer, param_list=param_list)
 
         if self.dop_snref:
-            ddds = diag_layer.diag_data_dictionary_spec
-            self._dop = odxrequire(ddds.all_data_object_properties.get(self.dop_snref))
+            all_dops = diag_layer.diag_data_dictionary_spec.all_data_object_properties
+            self._dop = resolve_snref(self.dop_snref, all_dops, DopBase)
 
     @property
     def dop(self) -> DopBase:
-        """may be a DataObjectProperty, a Structure or None"""
+        """This is usually a DataObjectProperty or a Structure object"""
 
-        return odxrequire(
-            self._dop, "Specifying a data object property is mandatory but it "
-            "could not be resolved")
+        return self._dop
 
     @override
     def get_static_bit_length(self) -> Optional[int]:

odxtools/parameters/physicalconstantparameter.py

@@ -12,7 +12,7 @@ from ..exceptions import DecodeError, EncodeError, odxraise, odxrequire
 from ..odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
 from ..odxtypes import ParameterValue
 from ..utils import dataclass_fields_asdict
-from .parameter import ParameterType
+from .parameter import Parameter, ParameterType
 from .parameterwithdop import ParameterWithDOP
 
 if TYPE_CHECKING:
@@ -50,8 +50,9 @@ class PhysicalConstantParameter(ParameterWithDOP):
         super()._resolve_odxlinks(odxlinks)
 
     @override
-    def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
-        super()._resolve_snrefs(diag_layer)
+    def _parameter_resolve_snrefs(self, diag_layer: "DiagLayer", *,
+                                  param_list: List[Parameter]) -> None:
+        super()._parameter_resolve_snrefs(diag_layer, param_list=param_list)
 
         dop = odxrequire(self.dop)
         if not isinstance(dop, DataObjectProperty):

odxtools/parameters/tablekeyparameter.py

@@ -8,7 +8,7 @@ from typing_extensions import final, override
 from ..decodestate import DecodeState
 from ..encodestate import EncodeState
 from ..exceptions import DecodeError, EncodeError, odxraise, odxrequire
-from ..odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef
+from ..odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef, resolve_snref
 from ..odxtypes import ParameterValue
 from ..utils import dataclass_fields_asdict
 from .parameter import Parameter, ParameterType
@@ -94,19 +94,19 @@ class TableKeyParameter(Parameter):
             self._table = self._table_row.table
 
     @override
-    def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
-        super()._resolve_snrefs(diag_layer)
+    def _parameter_resolve_snrefs(self, diag_layer: "DiagLayer", *,
+                                  param_list: List[Parameter]) -> None:
+        super()._parameter_resolve_snrefs(diag_layer, param_list=param_list)
 
         if self.table_snref is not None:
-            ddd_spec = diag_layer.diag_data_dictionary_spec
-            self._table = ddd_spec.tables[self.table_snref]
+            tables = diag_layer.diag_data_dictionary_spec.tables
+            self._table = resolve_snref(self.table_snref, tables, Table)
         if self.table_row_snref is not None:
             # make sure that we know the table to which the table row
             # SNREF is relative to.
-            table = odxrequire(
-                self._table, "If a table-row short name reference is defined, a "
-                "table must also be specified.")
-            self._table_row = table.table_rows[self.table_row_snref]
+            table = odxrequire(self._table,
+                               "If a table-row is referenced, a table must also be referenced.")
+            self._table_row = resolve_snref(self.table_row_snref, table.table_rows, TableRow)
 
     @property
     def table(self) -> "Table":

odxtools/parameters/tablestructparameter.py

@@ -3,12 +3,12 @@ from dataclasses import dataclass
 from typing import TYPE_CHECKING, Any, Dict, List, Optional, cast
 from xml.etree import ElementTree
 
-from typing_extensions import final, override
+from typing_extensions import override
 
 from ..decodestate import DecodeState
 from ..encodestate import EncodeState
 from ..exceptions import DecodeError, EncodeError, odxraise, odxrequire
-from ..odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef
+from ..odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef, resolve_snref
 from ..odxtypes import ParameterValue
 from ..utils import dataclass_fields_asdict
 from .parameter import Parameter, ParameterType
@@ -60,31 +60,12 @@ class TableStructParameter(Parameter):
             self._table_key = odxlinks.resolve(self.table_key_ref, TableKeyParameter)
 
     @override
-    @final
-    def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
-        raise RuntimeError(f"Calling TableStructParameter._resolve_snref() is not allowed. "
-                           f"Use ._table_struct_resolve_snrefs() instead.")
-
-    def _table_struct_resolve_snrefs(self, diag_layer: "DiagLayer", *,
-                                     param_list: List[Parameter]) -> None:
-        super()._resolve_snrefs(diag_layer)
+    def _parameter_resolve_snrefs(self, diag_layer: "DiagLayer", *,
+                                  param_list: List[Parameter]) -> None:
+        super()._parameter_resolve_snrefs(diag_layer, param_list=param_list)
 
         if self.table_key_snref is not None:
-            tk_candidates = [p for p in param_list if p.short_name == self.table_key_snref]
-            if len(tk_candidates) > 1:
-                odxraise(f"Short name reference '{self.table_key_snref}' could "
-                         f"not be uniquely resolved.")
-            elif len(tk_candidates) == 0:
-                odxraise(f"Short name reference '{self.table_key_snref}' could "
-                         f"not be resolved.")
-                return
-
-            tk = tk_candidates[0]
-            if not isinstance(tk, TableKeyParameter):
-                odxraise(f"Table struct '{self.short_name}' references non-TableKey parameter "
-                         f"`{self.table_key_snref}' as its table key.")
-
-            self._table_key = tk
+            self._table_key = resolve_snref(self.table_key_snref, param_list, TableKeyParameter)
 
     @property
     def table_key(self) -> TableKeyParameter:

odxtools/parameters/valueparameter.py

@@ -11,7 +11,7 @@ from ..exceptions import EncodeError, odxraise, odxrequire
 from ..odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
 from ..odxtypes import AtomicOdxType, ParameterValue
 from ..utils import dataclass_fields_asdict
-from .parameter import ParameterType
+from .parameter import Parameter, ParameterType
 from .parameterwithdop import ParameterWithDOP
 
 if TYPE_CHECKING:
@@ -50,8 +50,9 @@ class ValueParameter(ParameterWithDOP):
         super()._resolve_odxlinks(odxlinks)
 
     @override
-    def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
-        super()._resolve_snrefs(diag_layer)
+    def _parameter_resolve_snrefs(self, diag_layer: "DiagLayer", *,
+                                  param_list: List[Parameter]) -> None:
+        super()._parameter_resolve_snrefs(diag_layer, param_list=param_list)
 
         if self.physical_default_value_raw is not None:
             dop = odxrequire(self.dop)

odxtools/statechart.py

@@ -6,7 +6,7 @@ from xml.etree import ElementTree
 from .element import IdentifiableElement
 from .exceptions import odxrequire
 from .nameditemlist import NamedItemList
-from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
+from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, resolve_snref
 from .state import State
 from .statetransition import StateTransition
 from .utils import dataclass_fields_asdict
@@ -68,19 +68,15 @@ class StateChart(IdentifiableElement):
         for st in self.states:
             st._resolve_odxlinks(odxlinks)
 
-        # For now, we assume that the start state short name ref
-        # points to a state local to the state chart. TODO: The XML
+    def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
+        # For now, we assume that the start state short name reference
+        # points to a local state of the state chart. TODO: The XSD
         # allows to define state charts without any states, yet the
         # start state SNREF is mandatory. Is this a gap in the spec or
         # does it allow "foreign" start states? If the latter, what
         # does that mean?
-        self._start_state: State
-        for st in self.states:
-            if st.short_name == self.start_state_snref:
-                self._start_state = st
-                break
+        self._start_state = resolve_snref(self.start_state_snref, self.states, State)
 
-    def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
         for st in self.states:
             st._resolve_snrefs(diag_layer)
 

odxtools/statetransition.py

@@ -5,7 +5,7 @@ from xml.etree import ElementTree
 
 from .element import IdentifiableElement
 from .exceptions import odxrequire
-from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
+from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, resolve_snref
 from .state import State
 from .utils import dataclass_fields_asdict
 
@@ -55,10 +55,5 @@ class StateTransition(IdentifiableElement):
     # chart. To mitigate this a bit, the non-standard parameters are
     # keyword-only...
     def _resolve_snrefs(self, diag_layer: "DiagLayer", *, states: Iterable[State]) -> None:
-        self._source_state: State
-        self._target_state: State
-        for st in states:
-            if st.short_name == self.source_snref:
-                self._source_state = st
-            if st.short_name == self.target_snref:
-                self._target_state = st
+        self._source_state = resolve_snref(self.source_snref, states, State)
+        self._target_state = resolve_snref(self.target_snref, states, State)

odxtools/staticfield.py

@@ -1,6 +1,6 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Dict, List
+from typing import TYPE_CHECKING, Any, Dict, List, Sequence
 from xml.etree import ElementTree
 
 from typing_extensions import override
@@ -51,15 +51,20 @@ class StaticField(Field):
     def encode_into_pdu(self, physical_value: ParameterValue, encode_state: EncodeState) -> None:
 
         if not isinstance(physical_value,
-                          (tuple, list)) or len(physical_value) != self.fixed_number_of_items:
+                          Sequence) or len(physical_value) != self.fixed_number_of_items:
             odxraise(f"Value for static field '{self.short_name}' "
                      f"must be a list of size {self.fixed_number_of_items}")
 
-        for val in physical_value:
+        orig_is_end_of_pdu = encode_state.is_end_of_pdu
+        encode_state.is_end_of_pdu = False
+        for i, val in enumerate(physical_value):
             if not isinstance(val, dict):
                 odxraise(f"The individual parameter values for static field '{self.short_name}' "
                          f"must be dictionaries for structure '{self.structure.short_name}'")
 
+            if i == len(physical_value) - 1:
+                encode_state.is_end_of_pdu = orig_is_end_of_pdu
+
             pos_before = encode_state.cursor_byte_position
             self.structure.encode_into_pdu(val, encode_state)
             pos_after = encode_state.cursor_byte_position
@@ -75,12 +80,18 @@ class StaticField(Field):
                 encode_state.emplace_bytes(b'\x00' * (self.item_byte_size -
                                                       (pos_after - pos_before)))
 
+        encode_state.is_end_of_pdu = orig_is_end_of_pdu
+
     @override
     def decode_from_pdu(self, decode_state: DecodeState) -> ParameterValue:
 
         odxassert(decode_state.cursor_bit_position == 0,
                   "No bit position can be specified for static length fields!")
 
+        orig_origin = decode_state.origin_byte_position
+        orig_cursor = decode_state.cursor_byte_position
+        decode_state.origin_byte_position = decode_state.cursor_byte_position
+
         result: List[ParameterValue] = []
         for _ in range(self.fixed_number_of_items):
             orig_cursor = decode_state.cursor_byte_position
@@ -94,4 +105,7 @@ class StaticField(Field):
 
             decode_state.cursor_byte_position = orig_cursor + self.item_byte_size
 
+        decode_state.origin_byte_position = orig_origin
+        decode_state.cursor_byte_position = max(orig_cursor, decode_state.cursor_byte_position)
+
         return result

odxtools/tablerow.py

@@ -9,7 +9,7 @@ from .dataobjectproperty import DataObjectProperty
 from .dtcdop import DtcDop
 from .element import IdentifiableElement
 from .exceptions import odxassert, odxraise, odxrequire
-from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef
+from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef, resolve_snref
 from .odxtypes import AtomicOdxType
 from .specialdatagroup import SpecialDataGroup
 from .utils import dataclass_fields_asdict
@@ -128,9 +128,11 @@ class TableRow(IdentifiableElement):
         ddd_spec = diag_layer.diag_data_dictionary_spec
 
         if self.structure_snref is not None:
-            self._structure = odxrequire(ddd_spec.structures.get(self.structure_snref))
+            self._structure = resolve_snref(self.structure_snref, ddd_spec.structures,
+                                            BasicStructure)
         if self.dop_snref is not None:
-            self._dop = odxrequire(ddd_spec.data_object_props.get(self.dop_snref))
+            self._dop = resolve_snref(self.dop_snref, ddd_spec.data_object_props,
+                                      DataObjectProperty)
 
         for sdg in self.sdgs:
             sdg._resolve_snrefs(diag_layer)

odxtools/templates/macros/printDynamicEndmarkerField.xml.jinja2

@@ -0,0 +1,16 @@
+{#- -*- mode: sgml; tab-width: 1; indent-tabs-mode: nil -*-
+ #
+ # SPDX-License-Identifier: MIT
+-#}
+
+{%- import('macros/printElementId.xml.jinja2') as peid %}
+
+{%- macro printStaticField(demf) -%}
+<DYNAMIC-ENDMARKER-FIELD ID="{{demf.odx_id.local_id}}">
+ {{ peid.printElementIdSubtags(demf)|indent(1) }}
+ <BASIC-STRUCTURE-REF ID-REF="{{demf.structure_ref.ref_id}}" />
+ <DYN-END-DOP-REF ID-REF="{{demf.dyn_end_dop_ref.ref_id}}">
+   <TERMINATION-VALUE>{{demf.dyn_end_dop_ref.termination_value_raw}}</TERMINATION-VALUE>
+ </DYN-END-DOP-REF>
+</DYNAMIC-ENDMARKER-FIELD>
+{%- endmacro -%}

odxtools/templates/macros/printVariant.xml.jinja2

@@ -11,6 +11,7 @@
 {%- import('macros/printEndOfPdu.xml.jinja2') as peopdu %}
 {%- import('macros/printStaticField.xml.jinja2') as psf %}
 {%- import('macros/printDynamicLengthField.xml.jinja2') as pdlf %}
+{%- import('macros/printDynamicEndmarkerField.xml.jinja2') as pdemf %}
 {%- import('macros/printMux.xml.jinja2') as pm %}
 {%- import('macros/printEnvData.xml.jinja2') as ped %}
 {%- import('macros/printEnvDataDesc.xml.jinja2') as pedd %}
@@ -82,6 +83,13 @@
      {%- endfor %}
    </DYNAMIC-LENGTH-FIELDS>
    {%- endif %}
+   {%- if ddds.dynamic_endmarker_fields %}
+   <DYNAMIC-ENDMARKER-FIELDS>
+     {%- for demf in ddds.dynamic_endmarker_fields %}
+     {{ pdemf.printDynamicEndmarkerField(demf)|indent(3) }}
+     {%- endfor %}
+   </DYNAMIC-ENDMARKER-FIELDS>
+   {%- endif %}
    {%- if ddds.end_of_pdu_fields %}
    <END-OF-PDU-FIELDS>
      {%- for eopdu in ddds.end_of_pdu_fields %}

odxtools/version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '7.0.0'
-__version_tuple__ = version_tuple = (7, 0, 0)
+__version__ = version = '7.1.1'
+__version_tuple__ = version_tuple = (7, 1, 1)

{odxtools-7.0.0.dist-info → odxtools-7.1.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: odxtools
-Version: 7.0.0
+Version: 7.1.1
 Summary: Utilities to work with the ODX standard for automotive diagnostics
 Author-email: Katrin Bauer <katrin.bauer@mbition.io>, Andreas Lauser <andreas.lauser@mbition.io>, Ayoub Kaanich <kayoub5@live.com>
 Maintainer-email: Andreas Lauser <andreas.lauser@mbition.io>, Ayoub Kaanich <kayoub5@live.com>