odxtools 6.6.0__py3-none-any.whl → 6.7.0__py3-none-any.whl

odxtools/parameters/tablekeyparameter.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 ..decodestate import DecodeState
 from ..encodestate import EncodeState
 from ..exceptions import DecodeError, EncodeError, odxraise, odxrequire
-from ..odxlink import OdxLinkDatabase, OdxLinkId, OdxLinkRef
+from ..odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef
 from ..odxtypes import ParameterValue
+from ..utils import dataclass_fields_asdict
 from .parameter import Parameter, ParameterType
 
 if TYPE_CHECKING:
@@ -24,6 +28,33 @@ class TableKeyParameter(Parameter):
     table_row_snref: Optional[str]
     table_row_ref: Optional[OdxLinkRef]
 
+    @staticmethod
+    @override
+    def from_et(et_element: ElementTree.Element,
+                doc_frags: List[OdxDocFragment]) -> "TableKeyParameter":
+
+        kwargs = dataclass_fields_asdict(Parameter.from_et(et_element, doc_frags))
+
+        odx_id = odxrequire(OdxLinkId.from_et(et_element, doc_frags))
+
+        table_ref = OdxLinkRef.from_et(et_element.find("TABLE-REF"), doc_frags)
+        table_snref = None
+        if (table_snref_elem := et_element.find("TABLE-SNREF")) is not None:
+            table_snref = odxrequire(table_snref_elem.get("SHORT-NAME"))
+
+        table_row_ref = OdxLinkRef.from_et(et_element.find("TABLE-ROW-REF"), doc_frags)
+        table_row_snref = None
+        if (table_row_snref_elem := et_element.find("TABLE-ROW-SNREF")) is not None:
+            table_row_snref = odxrequire(table_row_snref_elem.get("SHORT-NAME"))
+
+        return TableKeyParameter(
+            odx_id=odx_id,
+            table_ref=table_ref,
+            table_snref=table_snref,
+            table_row_ref=table_row_ref,
+            table_row_snref=table_row_snref,
+            **kwargs)
+
     def __post_init__(self) -> None:
         self._table: "Table"
         self._table_row: Optional["TableRow"] = None
@@ -32,9 +63,11 @@ class TableKeyParameter(Parameter):
             odxraise("Either a table or a table row must be defined.")
 
     @property
+    @override
     def parameter_type(self) -> ParameterType:
         return "TABLE-KEY"
 
+    @override
     def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
         result = super()._build_odxlinks()
 
@@ -42,6 +75,7 @@ class TableKeyParameter(Parameter):
 
         return result
 
+    @override
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
         super()._resolve_odxlinks(odxlinks)
 
@@ -59,6 +93,7 @@ class TableKeyParameter(Parameter):
                 self._table_row = odxlinks.resolve(self.table_row_ref)
             self._table = self._table_row.table
 
+    @override
     def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
         super()._resolve_snrefs(diag_layer)
 
@@ -86,15 +121,18 @@ class TableKeyParameter(Parameter):
         return self._table_row
 
     @property
+    @override
     def is_required(self) -> bool:
         # TABLE-KEY parameters can be implicitly determined from the
         # corresponding TABLE-STRUCT
         return False
 
     @property
+    @override
     def is_settable(self) -> bool:
         return True
 
+    @override
     def get_coded_value_as_bytes(self, encode_state: EncodeState) -> bytes:
         tr_short_name = encode_state.parameter_values.get(self.short_name)
 
@@ -132,14 +170,12 @@ class TableKeyParameter(Parameter):
         bit_position = 0 if self.bit_position is None else self.bit_position
         return key_dop.convert_physical_to_bytes(tr.key, 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:
         if self.table_row is not None:
             # the table row to be used is statically specified -> no
             # need to decode anything!
@@ -147,7 +183,6 @@ class TableKeyParameter(Parameter):
         else:
             # Use DOP to decode
             key_dop = odxrequire(self.table.key_dop)
-            decode_state.cursor_bit_position = self.bit_position or 0
             key_dop_val = key_dop.decode_from_pdu(decode_state)
 
             table_row_candidates = [x for x in self.table.table_rows if x.key == key_dop_val]
@@ -162,6 +197,4 @@ class TableKeyParameter(Parameter):
             # update the decode_state's table key
             decode_state.table_keys[self.short_name] = table_row
 
-        decode_state.cursor_byte_position = max(decode_state.cursor_byte_position, orig_cursor)
-
         return phys_val

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
 
@@ -18,20 +22,37 @@ if TYPE_CHECKING:
 class ValueParameter(ParameterWithDOP):
     physical_default_value_raw: Optional[str]
 
+    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)
 
-        self._physical_default_value: Optional[AtomicOdxType] = None
         if self.physical_default_value_raw is not None:
             dop = odxrequire(self.dop)
             if not isinstance(dop, DataObjectProperty):
@@ -46,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>