odxtools 6.6.1__py3-none-any.whl → 6.7.1__py3-none-any.whl

odxtools/parameters/tablestructparameter.py

@@ -1,13 +1,17 @@
 # SPDX-License-Identifier: MIT
 import warnings
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Dict, Optional, cast
+from typing import TYPE_CHECKING, Any, Dict, List, Optional, cast
+from xml.etree import ElementTree
+
+from typing_extensions import override
 
 from ..decodestate import DecodeState
 from ..encodestate import EncodeState
-from ..exceptions import EncodeError, OdxWarning, odxraise
-from ..odxlink import OdxLinkDatabase, OdxLinkId, OdxLinkRef
+from ..exceptions import DecodeError, EncodeError, OdxWarning, odxraise, odxrequire
+from ..odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef
 from ..odxtypes import ParameterValue
+from ..utils import dataclass_fields_asdict
 from .parameter import Parameter, ParameterType
 from .tablekeyparameter import TableKeyParameter
 
@@ -21,23 +25,42 @@ class TableStructParameter(Parameter):
     table_key_ref: Optional[OdxLinkRef]
     table_key_snref: Optional[str]
 
+    @staticmethod
+    @override
+    def from_et(et_element: ElementTree.Element,
+                doc_frags: List[OdxDocFragment]) -> "TableStructParameter":
+
+        kwargs = dataclass_fields_asdict(Parameter.from_et(et_element, doc_frags))
+
+        table_key_ref = OdxLinkRef.from_et(et_element.find("TABLE-KEY-REF"), doc_frags)
+        table_key_snref = None
+        if (table_key_snref_elem := et_element.find("TABLE-KEY-SNREF")) is not None:
+            table_key_snref = odxrequire(table_key_snref_elem.get("SHORT-NAME"))
+
+        return TableStructParameter(
+            table_key_ref=table_key_ref, table_key_snref=table_key_snref, **kwargs)
+
     def __post_init__(self) -> None:
         if self.table_key_ref is None and self.table_key_snref is None:
             odxraise("Either table_key_ref or table_key_snref must be defined.")
 
     @property
+    @override
     def parameter_type(self) -> ParameterType:
         return "TABLE-STRUCT"
 
+    @override
     def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
         return super()._build_odxlinks()
 
+    @override
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
         super()._resolve_odxlinks(odxlinks)
 
         if self.table_key_ref is not None:
-            self._table_key = odxlinks.resolve(self.table_key_ref)
+            self._table_key = odxlinks.resolve(self.table_key_ref, TableKeyParameter)
 
+    @override
     def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
         super()._resolve_snrefs(diag_layer)
 
@@ -53,13 +76,16 @@ class TableStructParameter(Parameter):
         return self._table_key
 
     @property
+    @override
     def is_required(self) -> bool:
         return True
 
     @property
+    @override
     def is_settable(self) -> bool:
         return True
 
+    @override
     def get_coded_value_as_bytes(self, encode_state: EncodeState) -> bytes:
         physical_value = encode_state.parameter_values.get(self.short_name)
 
@@ -122,22 +148,21 @@ class TableStructParameter(Parameter):
         return tr.dop.convert_physical_to_bytes(
             tr_value, encode_state=encode_state, bit_position=bit_position)
 
+    @override
     def encode_into_pdu(self, encode_state: EncodeState) -> bytes:
         return super().encode_into_pdu(encode_state)
 
-    def decode_from_pdu(self, decode_state: DecodeState) -> ParameterValue:
-        orig_cursor = decode_state.cursor_byte_position
-        if self.byte_position is not None:
-            decode_state.cursor_byte_position = decode_state.origin_byte_position + self.byte_position
-
+    @override
+    def _decode_positioned_from_pdu(self, decode_state: DecodeState) -> ParameterValue:
         # find the selected table row
         key_name = self.table_key.short_name
 
         decode_state.table_keys[key_name]
         table_row = decode_state.table_keys.get(key_name)
         if table_row is None:
-            raise odxraise(f"No table key '{key_name}' found when decoding "
-                           f"table struct parameter '{str(self.short_name)}'")
+            odxraise(
+                f"No table key '{key_name}' found when decoding "
+                f"table struct parameter '{str(self.short_name)}'", DecodeError)
             dummy_val = cast(str, None), cast(int, None)
             return dummy_val
 
@@ -145,14 +170,11 @@ class TableStructParameter(Parameter):
         if table_row.dop is not None:
             dop = table_row.dop
             val = dop.decode_from_pdu(decode_state)
-            decode_state.cursor_byte_position = max(decode_state.cursor_byte_position, orig_cursor)
             return (table_row.short_name, val)
         elif table_row.structure is not None:
             val = table_row.structure.decode_from_pdu(decode_state)
-            decode_state.cursor_byte_position = max(decode_state.cursor_byte_position, orig_cursor)
             return (table_row.short_name, val)
         else:
             # the table row associated with the key neither defines a
             # DOP nor a structure -> ignore it
-            decode_state.cursor_byte_position = max(decode_state.cursor_byte_position, orig_cursor)
             return (table_row.short_name, cast(int, None))

odxtools/parameters/valueparameter.py

@@ -1,12 +1,16 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Dict, Optional
+from typing import TYPE_CHECKING, Any, Dict, List, Optional
+from xml.etree import ElementTree
+
+from typing_extensions import override
 
 from ..dataobjectproperty import DataObjectProperty
 from ..encodestate import EncodeState
 from ..exceptions import odxraise, odxrequire
-from ..odxlink import OdxLinkDatabase, OdxLinkId
+from ..odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
 from ..odxtypes import AtomicOdxType
+from ..utils import dataclass_fields_asdict
 from .parameter import ParameterType
 from .parameterwithdop import ParameterWithDOP
 
@@ -21,16 +25,31 @@ class ValueParameter(ParameterWithDOP):
     def __post_init__(self) -> None:
         self._physical_default_value: Optional[AtomicOdxType] = None
 
+    @staticmethod
+    @override
+    def from_et(et_element: ElementTree.Element,
+                doc_frags: List[OdxDocFragment]) -> "ValueParameter":
+
+        kwargs = dataclass_fields_asdict(ParameterWithDOP.from_et(et_element, doc_frags))
+
+        physical_default_value_raw = et_element.findtext("PHYSICAL-DEFAULT-VALUE")
+
+        return ValueParameter(physical_default_value_raw=physical_default_value_raw, **kwargs)
+
     @property
+    @override
     def parameter_type(self) -> ParameterType:
         return "VALUE"
 
+    @override
     def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
         return super()._build_odxlinks()
 
+    @override
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
         super()._resolve_odxlinks(odxlinks)
 
+    @override
     def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
         super()._resolve_snrefs(diag_layer)
 
@@ -48,13 +67,16 @@ class ValueParameter(ParameterWithDOP):
         return self._physical_default_value
 
     @property
+    @override
     def is_required(self) -> bool:
         return self._physical_default_value is None
 
     @property
+    @override
     def is_settable(self) -> bool:
         return True
 
+    @override
     def get_coded_value_as_bytes(self, encode_state: EncodeState) -> bytes:
         physical_value = encode_state.parameter_values.get(self.short_name,
                                                            self.physical_default_value)

odxtools/paramlengthinfotype.py

@@ -30,7 +30,10 @@ class ParamLengthInfoType(DiagCodedType):
         """Recursively resolve any odxlinks references"""
         super()._resolve_odxlinks(odxlinks)
 
-        self._length_key = odxlinks.resolve(self.length_key_ref)
+        if TYPE_CHECKING:
+            self._length_key = odxlinks.resolve(self.length_key_ref, LengthKeyParameter)
+        else:
+            self._length_key = odxlinks.resolve(self.length_key_ref)
 
     def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
         """Recursively resolve any short-name references"""

odxtools/parentref.py

@@ -71,7 +71,10 @@ class ParentRef:
         return {}
 
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
-        self._layer = odxlinks.resolve(self.layer_ref)
+        if TYPE_CHECKING:
+            self._layer = odxlinks.resolve(self.layer_ref, DiagLayer)
+        else:
+            self._layer = odxlinks.resolve(self.layer_ref)
 
     def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
         pass

odxtools/scaleconstr.py

@@ -1,11 +1,12 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
 from enum import Enum
-from typing import Optional
+from typing import List, Optional
 from xml.etree import ElementTree
 
 from .compumethods.limit import Limit
 from .exceptions import odxraise, odxrequire
+from .odxlink import OdxDocFragment
 from .odxtypes import DataType
 from .utils import create_description_from_et
 
@@ -27,14 +28,18 @@ class ScaleConstr:
     lower_limit: Optional[Limit]
     upper_limit: Optional[Limit]
     validity: ValidType
+    value_type: DataType
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element, internal_type: DataType) -> "ScaleConstr":
+    def scale_constr_from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment], *,
+                             value_type: DataType) -> "ScaleConstr":
         short_label = et_element.findtext("SHORT-LABEL")
         description = create_description_from_et(et_element.find("DESC"))
 
-        lower_limit = Limit.from_et(et_element.find("LOWER-LIMIT"), internal_type=internal_type)
-        upper_limit = Limit.from_et(et_element.find("UPPER-LIMIT"), internal_type=internal_type)
+        lower_limit = Limit.limit_from_et(
+            et_element.find("LOWER-LIMIT"), doc_frags, value_type=value_type)
+        upper_limit = Limit.limit_from_et(
+            et_element.find("UPPER-LIMIT"), doc_frags, value_type=value_type)
 
         validity_str = odxrequire(et_element.get("VALIDITY"))
         try:
@@ -47,4 +52,5 @@ class ScaleConstr:
             description=description,
             lower_limit=lower_limit,
             upper_limit=upper_limit,
-            validity=validity)
+            validity=validity,
+            value_type=value_type)

odxtools/statetransition.py

@@ -20,7 +20,7 @@ class StateTransition(IdentifiableElement):
     """
     source_snref: str
     target_snref: str
-    #external_access_method: Optional[ExternalAccessMethod] # TODO
+    # external_access_method: Optional[ExternalAccessMethod] # TODO
 
     @property
     def source_state(self) -> State:

odxtools/staticfield.py

@@ -0,0 +1,101 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any, Dict, List
+from xml.etree import ElementTree
+
+from typing_extensions import override
+
+from .decodestate import DecodeState
+from .encodestate import EncodeState
+from .exceptions import odxassert, odxraise, odxrequire
+from .field import Field
+from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
+from .odxtypes import ParameterValue
+from .utils import dataclass_fields_asdict
+
+if TYPE_CHECKING:
+    from .diaglayer import DiagLayer
+
+
+@dataclass
+class StaticField(Field):
+    """Array of a fixed number of structure objects"""
+    fixed_number_of_items: int
+    item_byte_size: int
+
+    @staticmethod
+    @override
+    def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "StaticField":
+        kwargs = dataclass_fields_asdict(Field.from_et(et_element, doc_frags))
+
+        fixed_number_of_items = int(odxrequire(et_element.findtext('FIXED-NUMBER-OF-ITEMS')))
+        item_byte_size = int(odxrequire(et_element.findtext('ITEM-BYTE-SIZE')))
+
+        return StaticField(
+            fixed_number_of_items=fixed_number_of_items, item_byte_size=item_byte_size, **kwargs)
+
+    @override
+    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+        odxlinks = super()._build_odxlinks()
+        return odxlinks
+
+    @override
+    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
+        super()._resolve_odxlinks(odxlinks)
+
+    @override
+    def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
+        super()._resolve_snrefs(diag_layer)
+
+    @override
+    def convert_physical_to_bytes(
+        self,
+        physical_value: ParameterValue,
+        encode_state: EncodeState,
+        bit_position: int = 0,
+    ) -> bytes:
+        if not isinstance(physical_value,
+                          (tuple, list)) 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}")
+
+        result = bytearray()
+        for val in 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}'")
+
+            data = self.structure.convert_physical_to_bytes(val, encode_state)
+
+            if len(data) > self.item_byte_size:
+                odxraise(f"Insufficient item byte size for static field {self.short_name}: "
+                         f"Is {self.item_byte_size} bytes, but need at least {len(data)} bytes")
+                data = data[:self.item_byte_size]
+            elif len(data) < self.item_byte_size:
+                # add some padding bytes
+                data = data.ljust(self.item_byte_size, b'\x00')
+
+            result += data
+
+        return result
+
+    @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!")
+
+        result: List[ParameterValue] = []
+        for _ in range(self.fixed_number_of_items):
+            orig_cursor = decode_state.cursor_byte_position
+
+            if decode_state.cursor_byte_position - orig_cursor > self.item_byte_size:
+                odxraise(f"Insufficient item byte size for static field {self.short_name}: "
+                         f"Is {self.item_byte_size} bytes, but need at least "
+                         f"{decode_state.cursor_byte_position - orig_cursor} bytes")
+
+            result.append(self.structure.decode_from_pdu(decode_state))
+
+            decode_state.cursor_byte_position = orig_cursor + self.item_byte_size
+
+        return result

odxtools/table.py

@@ -45,7 +45,8 @@ class Table(IdentifiableElement):
         for sub_elem in et_element:
             if sub_elem.tag == "TABLE-ROW":
                 table_rows_raw.append(
-                    TableRow.from_et(sub_elem, doc_frags, table_ref=OdxLinkRef.from_id(odx_id)))
+                    TableRow.tablerow_from_et(
+                        sub_elem, doc_frags, table_ref=OdxLinkRef.from_id(odx_id)))
             elif sub_elem.tag == "TABLE-ROW-REF":
                 table_rows_raw.append(OdxLinkRef.from_et(sub_elem, doc_frags))
 

odxtools/tablerow.py

@@ -51,9 +51,13 @@ class TableRow(IdentifiableElement):
         )
 
     @staticmethod
-    def from_et(  # type: ignore[override]
-            et_element: ElementTree.Element, doc_frags: List[OdxDocFragment], *,
-            table_ref: OdxLinkRef) -> "TableRow":
+    def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> Any:
+        raise RuntimeError(
+            "Calling TableRow.from_et() is not allowed. Use TableRow.tablerow_from_et().")
+
+    @staticmethod
+    def tablerow_from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment], *,
+                         table_ref: OdxLinkRef) -> "TableRow":
         """Reads a TABLE-ROW."""
         kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, doc_frags))
         semantic = et_element.get("SEMANTIC")
@@ -95,7 +99,10 @@ class TableRow(IdentifiableElement):
             if not isinstance(self._dop, (DataObjectProperty, DtcDop)):
                 odxraise("The DOP-REF of TABLE-ROWs must reference a simple DOP!")
 
-        self._table = odxlinks.resolve(self.table_ref)
+        if TYPE_CHECKING:
+            self._table = odxlinks.resolve(self.table_ref, Table)
+        else:
+            self._table = odxlinks.resolve(self.table_ref)
 
         for sdg in self.sdgs:
             sdg._resolve_odxlinks(odxlinks)

odxtools/templates/macros/printDOP.xml.jinja2

@@ -43,12 +43,24 @@
 {%- endif %}
 {%- endmacro -%}
 
-{%- macro printLimitValue(lv) -%}
-{%- if hasattr(lv, 'hex') -%}
-{#- bytes or bytarray limit #}
-{{lv.hex()}}
-{%- else -%}
-{{lv}}
+{%- macro printLimit(tag_name, limit_obj) -%}
+{%- if limit_obj is not none %}
+<{{tag_name}}
+{%- if limit_obj.interval_type is not none %}
+  {{- make_xml_attrib("INTERVAL-TYPE", limit_obj.interval_type.value) }}
+  {%- endif %}
+{%- if limit_obj.value_raw is none %}
+  {#- #}/>
+{%- else %}
+  {#- #}>
+  {%- if hasattr(limit_obj._value, 'hex') -%}
+  {#- bytes or bytarray limit #}
+  {{- limit_obj._value.hex().upper() }}
+  {%- else -%}
+  {{- limit_obj._value }}
+  {%- endif -%}
+</{{tag_name}}>
+{%- endif -%}
 {%- endif -%}
 {%- endmacro -%}
 
@@ -62,8 +74,8 @@
     {{sc.description}}
   </DESC>
   {%- endif %}
-  <LOWER-LIMIT>{{printLimitValue(sc.lower_limit.value)}}</LOWER-LIMIT>
-  <UPPER-LIMIT>{{printLimitValue(sc.upper_limit.value)}}</UPPER-LIMIT>
+  {{printLimit("LOWER-LIMIT", sc.lower_limit) }}
+  {{printLimit("UPPER-LIMIT", sc.upper_limit) }}
 </SCALE-CONSTR>
 {%- endmacro -%}
 
@@ -73,12 +85,8 @@
 {%- else %}
 <INTERNAL-CONSTR>
 {%- endif %}
-  {%- if ic.lower_limit %}
-  <LOWER-LIMIT>{{printLimitValue(ic.lower_limit.value)}}</LOWER-LIMIT>
-  {%- endif %}
-  {%- if ic.upper_limit %}
-  <UPPER-LIMIT>{{printLimitValue(ic.upper_limit.value)}}</UPPER-LIMIT>
-  {%- endif %}
+  {{printLimit("LOWER-LIMIT", ic.lower_limit) }}
+  {{printLimit("UPPER-LIMIT", ic.upper_limit) }}
   {%- if ic.scale_constrs %}
   <SCALE-CONSTRS>
   {%- for sc in ic.scale_constrs %}
@@ -109,12 +117,8 @@
     {{cs.description}}
     </DESC>
    {%- endif %}
-   {%- if cs.lower_limit is not none %}
-     <LOWER-LIMIT>{{printLimitValue(cs.lower_limit.value)}}</LOWER-LIMIT>
-   {%- endif %}
-   {%- if cs.upper_limit is not none %}
-     <UPPER-LIMIT>{{printLimitValue(cs.upper_limit.value)}}</UPPER-LIMIT>
-   {%- endif %}
+   {{printLimit("LOWER-LIMIT", cs.lower_limit) }}
+   {{printLimit("UPPER-LIMIT", cs.upper_limit) }}
    {%- if cs.compu_inverse_value is not none %}
     <COMPU-INVERSE-VALUE>
      <V>{{cs.compu_inverse_value}}</V>
@@ -141,12 +145,8 @@
  <COMPU-INTERNAL-TO-PHYS>
 		<COMPU-SCALES>
 			<COMPU-SCALE>
-   {%- if cm.internal_lower_limit is not none and cm.internal_lower_limit.interval_type.value != "INFINITE" %}
-				<LOWER-LIMIT>{{printLimitValue(cm.internal_lower_limit.value)}}</LOWER-LIMIT>
-   {%- endif %}
-   {%- if cm.internal_upper_limit is not none and cm.internal_upper_limit.interval_type.value != "INFINITE" %}
-				<UPPER-LIMIT>{{printLimitValue(cm.internal_upper_limit.value)}}</UPPER-LIMIT>
-   {%- endif %}
+     {{printLimit("LOWER-LIMIT", cm.internal_lower_limit) }}
+     {{printLimit("UPPER-LIMIT", cm.internal_upper_limit) }}
 				<COMPU-RATIONAL-COEFFS>
 					<COMPU-NUMERATOR>
 						<V>{{cm.offset}}</V>
@@ -166,12 +166,8 @@
 		<COMPU-SCALES>
   {%- for lm in cm.linear_methods %}
  		<COMPU-SCALE>
-   {%- if lm.internal_lower_limit is not none and lm.internal_lower_limit.interval_type.value != "INFINITE" %}
-				<LOWER-LIMIT>{{printLimitValue(lm.internal_lower_limit.value)}}</LOWER-LIMIT>
-   {%- endif %}
-   {%- if lm.internal_upper_limit is not none and lm.internal_upper_limit.interval_type.value != "INFINITE" %}
-				<UPPER-LIMIT>{{printLimitValue(lm.internal_upper_limit.value)}}</UPPER-LIMIT>
-   {%- endif %}
+    {{printLimit("LOWER-LIMIT", lm.internal_lower_limit) }}
+    {{printLimit("UPPER-LIMIT", lm.internal_upper_limit) }}
 				<COMPU-RATIONAL-COEFFS>
 					<COMPU-NUMERATOR>
 							<V>{{lm.offset}}</V>
@@ -191,8 +187,8 @@
  <COMPU-INTERNAL-TO-PHYS>
   <COMPU-SCALES>
   {%- for idx in range( cm.internal_points | length ) %}
-   <COMPU-SCALE>
-    <LOWER-LIMIT INTERVAL-TYPE="CLOSED">{{ printLimitValue(cm.internal_points[idx]) }}</LOWER-LIMIT>
+  <COMPU-SCALE>
+    <LOWER-LIMIT>{{ cm.internal_points[idx] }}</LOWER-LIMIT>
     <COMPU-CONST>
      <V>{{ cm.physical_points[idx] }}</V>
     </COMPU-CONST>

odxtools/templates/macros/printMux.xml.jinja2

@@ -4,6 +4,7 @@
 -#}
 
 {%- import('macros/printElementId.xml.jinja2') as peid %}
+{%- import('macros/printDOP.xml.jinja2') as pdop %}
 
 {%- macro printMux(mux) %}
 <MUX ID="{{mux.odx_id.local_id}}"
@@ -40,8 +41,8 @@
       {%- if case.structure_snref is not none %}
       <STRUCTURE-SNREF SHORT_NAME="{{case.structure_snref}}"/>
       {%- endif %}
-      <LOWER-LIMIT>{{case.lower_limit}}</LOWER-LIMIT>
-      <UPPER-LIMIT>{{case.upper_limit}}</UPPER-LIMIT>
+      {{ pdop.printLimit("LOWER-LIMIT", case.lower_limit) }}
+      {{ pdop.printLimit("UPPER-LIMIT", case.upper_limit) }}
     </CASE>
     {%- endfor %}
   </CASES>

odxtools/templates/macros/printParam.xml.jinja2

@@ -8,17 +8,17 @@
 {%- import('macros/printSpecialData.xml.jinja2') as psd %}
 
 {%- macro printParam(param) -%}
-{%- if param.semantic is not none %}
-{%-  set semattrib = " SEMANTIC=\""+param.semantic+"\"" -%}
-{%- else %}
-{%-  set semattrib = "" -%}
-{%- endif -%}
-{%- if param.parameter_type == "TABLE-KEY" and param.odx_id is not none  %}
-<PARAM {{semattrib}} ID="{{param.odx_id.local_id}}" xsi:type="{{param.parameter_type}}">
+{%- set semattrib = make_xml_attrib("SEMANTIC", param.semantic) -%}
+{%- if param.parameter_type == "TABLE-KEY"  %}
+<PARAM {{ semattrib }}
+  {{- make_xml_attrib("ID", param.odx_id and param.odx_id.local_id) }}
+  xsi:type="{{param.parameter_type}}">
 {%- elif param.parameter_type == "SYSTEM" %}
-<PARAM SYSPARAM="{{param.sysparam}}" xsi:type="{{param.parameter_type}}">
+<PARAM {{ semattrib }}
+  {{- make_xml_attrib("SYSPARAM", param.sysparam) }}
+  xsi:type="{{param.parameter_type}}">
 {%- else %}
-<PARAM {{semattrib}} xsi:type="{{param.parameter_type}}">
+<PARAM {{ semattrib }} xsi:type="{{param.parameter_type}}">
 {%- endif%}
  {{ peid.printElementIdSubtags(param)|indent(1) }}
  {{- psd.printSpecialDataGroups(param.sdgs)|indent(1, first=True) }}

odxtools/templates/macros/printStaticField.xml.jinja2

@@ -0,0 +1,15 @@
+{#- -*- mode: sgml; tab-width: 1; indent-tabs-mode: nil -*-
+ #
+ # SPDX-License-Identifier: MIT
+-#}
+
+{%- import('macros/printElementId.xml.jinja2') as peid %}
+
+{%- macro printStaticField(sf) -%}
+<STATIC-FIELD ID="{{sf.odx_id.local_id}}">
+ {{ peid.printElementIdSubtags(sf)|indent(1) }}
+ <BASIC-STRUCTURE-REF ID-REF="{{sf.structure_ref.ref_id}}" />
+ <FIXED-NUMBER-OF-ITEMS>{{sf.fixed_number_of_items}}</FIXED-NUMBER-OF-ITEMS>
+ <ITEM-BYTE-SIZE>{{sf.item_byte_size}}</ITEM-BYTE-SIZE>
+</STATIC-FIELD>
+{%- endmacro -%}

odxtools/templates/macros/printVariant.xml.jinja2

@@ -9,6 +9,7 @@
 {%- import('macros/printFunctionalClass.xml.jinja2') as pfc %}
 {%- import('macros/printStructure.xml.jinja2') as pst %}
 {%- import('macros/printEndOfPdu.xml.jinja2') as peopdu %}
+{%- import('macros/printStaticField.xml.jinja2') as psf %}
 {%- import('macros/printDynamicLengthField.xml.jinja2') as pdlf %}
 {%- import('macros/printMux.xml.jinja2') as pm %}
 {%- import('macros/printEnvData.xml.jinja2') as ped %}
@@ -67,6 +68,13 @@
      {%- endfor %}
    </STRUCTURES>
    {%- endif %}
+   {%- if ddds.static_fields %}
+   <STATIC-FIELDS>
+     {%- for sf in ddds.static_fields %}
+     {{ psf.printStaticField(sf)|indent(3) }}
+     {%- endfor %}
+   </STATIC-FIELDS>
+   {%- endif %}
    {%- if ddds.dynamic_length_fields %}
    <DYNAMIC-LENGTH-FIELDS>
      {%- for dlf in ddds.dynamic_length_fields %}

odxtools/uds.py

@@ -173,6 +173,6 @@ def is_response_pending(telegram_payload: bytes, request_sid: Optional[int] = No
 
 
 # previous versions of odxtools had a typo here. hit happens!
-@deprecated(details="use is_response_pending()")
+@deprecated(details="use is_response_pending()")  # type: ignore[misc]
 def is_reponse_pending(telegram_payload: bytes, request_sid: Optional[int] = None) -> bool:
-    return is_reponse_pending(telegram_payload, request_sid)
+    return is_response_pending(telegram_payload, request_sid)

odxtools/version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '6.6.1'
-__version_tuple__ = version_tuple = (6, 6, 1)
+__version__ = version = '6.7.1'
+__version_tuple__ = version_tuple = (6, 7, 1)

odxtools/write_pdx_file.py

@@ -120,15 +120,15 @@ def write_pdx_file(
             creation_date = file_cdate.strftime("%Y-%m-%dT%H:%M:%S")
 
             mime_type = "text/plain"
-            if template_file_name.endswith(".odx-cs"):
+            if output_file_name.endswith(".odx-cs"):
                 mime_type = "application/x-asam.odx.odx-cs"
-            elif template_file_name.endswith(".odx-d"):
+            elif output_file_name.endswith(".odx-d"):
                 mime_type = "application/x-asam.odx.odx-d"
 
             zf_name = os.path.basename(output_file_name)
             with zf.open(zf_name, "w") as out_file:
                 file_index.append((zf_name, creation_date, mime_type))
-                out_file.write(data)  # type: ignore
+                out_file.write(data)
 
         jinja_env = jinja2.Environment(loader=jinja2.FileSystemLoader(templates_dir))
         jinja_env.globals["hasattr"] = hasattr