odxtools 9.6.1__py3-none-any.whl → 10.0.0__py3-none-any.whl

odxtools/comparamsubset.py

@@ -1,6 +1,6 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Dict, List, Optional
+from typing import TYPE_CHECKING, Any
 from xml.etree import ElementTree
 
 from .comparam import Comparam
@@ -22,12 +22,12 @@ class ComparamSubset(OdxCategory):
     comparams: NamedItemList[Comparam]
     complex_comparams: NamedItemList[ComplexComparam]
     data_object_props: NamedItemList[DataObjectProperty]
-    unit_spec: Optional[UnitSpec]
-    category: Optional[str]  # mandatory in ODX 2.2, but non-existent in ODX 2.0
+    unit_spec: UnitSpec | None
+    category: str | None  # mandatory in ODX 2.2, but non-existent in ODX 2.0
 
     @staticmethod
     def from_et(et_element: ElementTree.Element,
-                doc_frags: List[OdxDocFragment]) -> "ComparamSubset":
+                doc_frags: list[OdxDocFragment]) -> "ComparamSubset":
 
         category_attrib = et_element.attrib.get("CATEGORY")
 
@@ -64,7 +64,7 @@ class ComparamSubset(OdxCategory):
             unit_spec=unit_spec,
             **kwargs)
 
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         odxlinks = super()._build_odxlinks()
 
         for comparam in self.comparams:

odxtools/complexcomparam.py

@@ -1,6 +1,6 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import Any, Dict, List, Optional, Union
+from typing import Any, Union
 from xml.etree import ElementTree
 
 from .basecomparam import BaseComparam
@@ -10,7 +10,7 @@ from .odxtypes import odxstr_to_bool
 from .snrefcontext import SnRefContext
 from .utils import dataclass_fields_asdict
 
-ComplexValue = List[Union[str, "ComplexValue"]]
+ComplexValue = list[Union[str, "ComplexValue"]]
 
 
 def create_complex_value_from_et(et_element: ElementTree.Element) -> ComplexValue:
@@ -26,8 +26,8 @@ def create_complex_value_from_et(et_element: ElementTree.Element) -> ComplexValu
 @dataclass
 class ComplexComparam(BaseComparam):
     subparams: NamedItemList[BaseComparam]
-    physical_default_value: Optional[ComplexValue]
-    allow_multiple_values_raw: Optional[bool]
+    physical_default_value: ComplexValue | None
+    allow_multiple_values_raw: bool | None
 
     @property
     def allow_multiple_values(self) -> bool:
@@ -35,7 +35,7 @@ class ComplexComparam(BaseComparam):
 
     @staticmethod
     def from_et(et_element: ElementTree.Element,
-                doc_frags: List[OdxDocFragment]) -> "ComplexComparam":
+                doc_frags: list[OdxDocFragment]) -> "ComplexComparam":
         kwargs = dataclass_fields_asdict(BaseComparam.from_et(et_element, doc_frags))
 
         # to avoid a cyclic import, create_any_comparam_from_et cannot
@@ -68,7 +68,7 @@ class ComplexComparam(BaseComparam):
         # extract the complex physical default value. (what's the
         # purpose of this? the sub-parameters can define their own
         # default values if a default is desired...)
-        complex_physical_default_value: Optional[ComplexValue] = None
+        complex_physical_default_value: ComplexValue | None = None
         if (cpdv_elem := et_element.find("COMPLEX-PHYSICAL-DEFAULT-VALUE")) is not None:
             complex_physical_default_value = create_complex_value_from_et(cpdv_elem)
 
@@ -80,7 +80,7 @@ class ComplexComparam(BaseComparam):
             allow_multiple_values_raw=allow_multiple_values_raw,
             **kwargs)
 
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         odxlinks = super()._build_odxlinks()
         for subparam in self.subparams:
             odxlinks.update(subparam._build_odxlinks())

odxtools/compositecodec.py

@@ -0,0 +1,191 @@
+# SPDX-License-Identifier: MIT
+import typing
+from typing import runtime_checkable
+
+from .codec import Codec
+from .decodestate import DecodeState
+from .encodestate import EncodeState
+from .exceptions import EncodeError, odxraise
+from .odxtypes import ParameterValue
+from .parameters.codedconstparameter import CodedConstParameter
+from .parameters.matchingrequestparameter import MatchingRequestParameter
+from .parameters.parameter import Parameter
+from .parameters.physicalconstantparameter import PhysicalConstantParameter
+
+
+@runtime_checkable
+class CompositeCodec(Codec, typing.Protocol):
+    """Any object which can be en- or decoded to be transferred over
+    the wire which is composed of multiple parameter implements this
+    API.
+
+    """
+
+    @property
+    def parameters(self) -> list[Parameter]:
+        return []
+
+    @property
+    def required_parameters(self) -> list[Parameter]:
+        return []
+
+    @property
+    def free_parameters(self) -> list[Parameter]:
+        return []
+
+
+# some helper functions useful for composite codec objects
+def composite_codec_get_static_bit_length(codec: CompositeCodec) -> int | None:
+    """Compute the length of a composite codec object in bits
+
+    This is basically the sum of the lengths of all parameters. If the
+    length of any parameter can only determined at runtime, `None` is
+    returned.
+    """
+
+    cursor = 0
+    byte_length = 0
+    for param in codec.parameters:
+        param_bit_length = param.get_static_bit_length()
+        if param_bit_length is None:
+            # We were not able to calculate a static bit length
+            return None
+        elif param.byte_position is not None:
+            cursor = param.byte_position
+
+        cursor += ((param.bit_position or 0) + param_bit_length + 7) // 8
+        byte_length = max(byte_length, cursor)
+
+    return byte_length * 8
+
+
+def composite_codec_get_required_parameters(codec: CompositeCodec) -> list[Parameter]:
+    """Return the list of parameters which are required to be
+    specified for encoding the composite codec object
+
+    I.e., all free parameters that do not exhibit a default value.
+    """
+    return [p for p in codec.parameters if p.is_required]
+
+
+def composite_codec_get_free_parameters(codec: CompositeCodec) -> list[Parameter]:
+    """Return the list of parameters which can be freely specified by
+    the user when encoding the composite codec object
+
+    This means all required parameters plus parameters that can be
+    omitted because they specify a default.
+    """
+    return [p for p in codec.parameters if p.is_settable]
+
+
+def composite_codec_get_coded_const_prefix(codec: CompositeCodec,
+                                           request_prefix: bytes = b'') -> bytes:
+    encode_state = EncodeState(coded_message=bytearray(), triggering_request=request_prefix)
+
+    for param in codec.parameters:
+        if (isinstance(param, MatchingRequestParameter) and param.request_byte_position < len(request_prefix)) or \
+            isinstance(param, CodedConstParameter|PhysicalConstantParameter) :
+            param.encode_into_pdu(physical_value=None, encode_state=encode_state)
+        else:
+            break
+
+    return encode_state.coded_message
+
+
+def composite_codec_encode_into_pdu(codec: CompositeCodec, physical_value: ParameterValue | None,
+                                    encode_state: EncodeState) -> None:
+    from .parameters.lengthkeyparameter import LengthKeyParameter
+    from .parameters.tablekeyparameter import TableKeyParameter
+
+    if not isinstance(physical_value, dict):
+        odxraise(
+            f"Expected a dictionary for the values of {codec.short_name}, "
+            f"got {type(physical_value).__name__}", EncodeError)
+    elif encode_state.cursor_bit_position != 0:
+        odxraise(
+            f"Compositional codec objecs must be byte aligned, but "
+            f"{codec.short_name} requested to be at bit position "
+            f"{encode_state.cursor_bit_position}", EncodeError)
+        encode_state.bit_position = 0
+
+    orig_origin = encode_state.origin_byte_position
+    encode_state.origin_byte_position = encode_state.cursor_byte_position
+
+    orig_is_end_of_pdu = encode_state.is_end_of_pdu
+    encode_state.is_end_of_pdu = False
+
+    # ensure that no values for unknown parameters are specified.
+    if not encode_state.allow_unknown_parameters:
+        param_names = {param.short_name for param in codec.parameters}
+        for param_value_name in physical_value:
+            if param_value_name not in param_names:
+                odxraise(f"Value for unknown parameter '{param_value_name}' specified "
+                         f"for composite codec object {codec.short_name}")
+
+    for param in codec.parameters:
+        if id(param) == id(codec.parameters[-1]):
+            # The last parameter of the composite codec object is at
+            # the end of the PDU if the codec object itself is at the
+            # end of the PDU.
+            #
+            # TODO: This assumes that the last parameter specified in
+            # the ODX is located last in the PDU...
+            encode_state.is_end_of_pdu = orig_is_end_of_pdu
+
+        if isinstance(param, LengthKeyParameter | TableKeyParameter):
+            # At this point, we encode a placeholder value for length-
+            # and table keys, since these can be specified
+            # implicitly (i.e., by means of parameters that use
+            # these keys). To avoid getting an "overlapping
+            # parameter" warning, we must encode a value of zero
+            # into the PDU here and add the real value of the
+            # parameter in a post-processing step.
+            param.encode_placeholder_into_pdu(
+                physical_value=physical_value.get(param.short_name), encode_state=encode_state)
+
+            continue
+
+        if param.is_required and param.short_name not in physical_value:
+            odxraise(f"No value for required parameter {param.short_name} specified", EncodeError)
+
+        param_phys_value = physical_value.get(param.short_name)
+        param.encode_into_pdu(physical_value=param_phys_value, encode_state=encode_state)
+
+        encode_state.journal.append((param, param_phys_value))
+
+    encode_state.is_end_of_pdu = False
+
+    # encode the length- and table keys. This cannot be done above
+    # because we allow these to be defined implicitly (i.e. they
+    # are defined by their respective users)
+    for param in codec.parameters:
+        if not isinstance(param, LengthKeyParameter | TableKeyParameter):
+            # the current parameter is neither a length- nor a table key
+            continue
+
+        # Encode the value of the key parameter into the message
+        param.encode_value_into_pdu(encode_state=encode_state)
+
+    encode_state.origin_byte_position = orig_origin
+
+
+def composite_codec_decode_from_pdu(codec: CompositeCodec,
+                                    decode_state: DecodeState) -> ParameterValue:
+    # move the origin since positions specified by sub-parameters of
+    # composite codec objects are relative to the beginning of the
+    # object.
+    orig_origin = decode_state.origin_byte_position
+    decode_state.origin_byte_position = decode_state.cursor_byte_position
+
+    result = {}
+    for param in codec.parameters:
+        value = param.decode_from_pdu(decode_state)
+
+        decode_state.journal.append((param, value))
+        result[param.short_name] = value
+
+    # decoding of the composite codec object finished. go back the
+    # original origin.
+    decode_state.origin_byte_position = orig_origin
+
+    return result

odxtools/compumethods/compucategory.py

@@ -0,0 +1,13 @@
+# SPDX-License-Identifier: MIT
+from enum import Enum
+
+
+class CompuCategory(Enum):
+    IDENTICAL = "IDENTICAL"
+    LINEAR = "LINEAR"
+    SCALE_LINEAR = "SCALE-LINEAR"
+    TEXTTABLE = "TEXTTABLE"
+    COMPUCODE = "COMPUCODE"
+    TAB_INTP = "TAB-INTP"
+    RAT_FUNC = "RAT-FUNC"
+    SCALE_RAT_FUNC = "SCALE-RAT-FUNC"

odxtools/compumethods/compucodecompumethod.py

@@ -1,6 +1,6 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import List, Optional, cast
+from typing import cast
 from xml.etree import ElementTree
 
 from ..exceptions import DecodeError, EncodeError, odxassert, odxraise
@@ -8,7 +8,8 @@ from ..odxlink import OdxDocFragment
 from ..odxtypes import AtomicOdxType, DataType
 from ..progcode import ProgCode
 from ..utils import dataclass_fields_asdict
-from .compumethod import CompuCategory, CompuMethod
+from .compucategory import CompuCategory
+from .compumethod import CompuMethod
 
 
 @dataclass
@@ -19,21 +20,21 @@ class CompuCodeCompuMethod(CompuMethod):
     """
 
     @property
-    def internal_to_phys_code(self) -> Optional[ProgCode]:
+    def internal_to_phys_code(self) -> ProgCode | None:
         if self.compu_internal_to_phys is None:
             return None
 
         return self.compu_internal_to_phys.prog_code
 
     @property
-    def phys_to_internal_code(self) -> Optional[ProgCode]:
+    def phys_to_internal_code(self) -> ProgCode | None:
         if self.compu_phys_to_internal is None:
             return None
 
         return self.compu_phys_to_internal.prog_code
 
     @staticmethod
-    def compu_method_from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment], *,
+    def compu_method_from_et(et_element: ElementTree.Element, doc_frags: list[OdxDocFragment], *,
                              internal_type: DataType,
                              physical_type: DataType) -> "CompuCodeCompuMethod":
         cm = CompuMethod.compu_method_from_et(

odxtools/compumethods/compuconst.py

@@ -1,6 +1,5 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import Optional
 from xml.etree import ElementTree
 
 from ..odxtypes import AtomicOdxType, DataType
@@ -8,13 +7,13 @@ from ..odxtypes import AtomicOdxType, DataType
 
 @dataclass
 class CompuConst:
-    v: Optional[str]
-    vt: Optional[str]
+    v: str | None
+    vt: str | None
 
     data_type: DataType
 
     @property
-    def value(self) -> Optional[AtomicOdxType]:
+    def value(self) -> AtomicOdxType | None:
         return self._value
 
     @staticmethod
@@ -26,6 +25,6 @@ class CompuConst:
         return CompuConst(v=v, vt=vt, data_type=data_type)
 
     def __post_init__(self) -> None:
-        self._value: Optional[AtomicOdxType] = self.vt
+        self._value: AtomicOdxType | None = self.vt
         if self.v is not None:
             self._value = self.data_type.from_string(self.v)

odxtools/compumethods/compudefaultvalue.py

@@ -1,6 +1,5 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import Optional
 from xml.etree import ElementTree
 
 from ..odxtypes import DataType
@@ -11,7 +10,7 @@ from .compuinversevalue import CompuInverseValue
 
 @dataclass
 class CompuDefaultValue(CompuConst):
-    compu_inverse_value: Optional[CompuInverseValue]
+    compu_inverse_value: CompuInverseValue | None
 
     @staticmethod
     def compuvalue_from_et(et_element: ElementTree.Element, *,

odxtools/compumethods/compuinternaltophys.py

@@ -1,6 +1,6 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import Any, Dict, List, Optional
+from typing import Any
 from xml.etree import ElementTree
 
 from ..odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
@@ -13,13 +13,13 @@ from .compuscale import CompuScale
 
 @dataclass
 class CompuInternalToPhys:
-    compu_scales: List[CompuScale]
-    prog_code: Optional[ProgCode]
-    compu_default_value: Optional[CompuDefaultValue]
+    compu_scales: list[CompuScale]
+    prog_code: ProgCode | None
+    compu_default_value: CompuDefaultValue | None
 
     @staticmethod
     def compu_internal_to_phys_from_et(et_element: ElementTree.Element,
-                                       doc_frags: List[OdxDocFragment], *, internal_type: DataType,
+                                       doc_frags: list[OdxDocFragment], *, internal_type: DataType,
                                        physical_type: DataType) -> "CompuInternalToPhys":
         compu_scales = [
             CompuScale.compuscale_from_et(
@@ -39,7 +39,7 @@ class CompuInternalToPhys:
         return CompuInternalToPhys(
             compu_scales=compu_scales, prog_code=prog_code, compu_default_value=compu_default_value)
 
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         result = {}
 
         if self.prog_code is not None:

odxtools/compumethods/compumethod.py

@@ -1,28 +1,17 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from enum import Enum
-from typing import Any, Dict, List, Optional
+from typing import Any
 from xml.etree import ElementTree
 
 from ..exceptions import odxraise
 from ..odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
 from ..odxtypes import AtomicOdxType, DataType
 from ..snrefcontext import SnRefContext
+from .compucategory import CompuCategory
 from .compuinternaltophys import CompuInternalToPhys
 from .compuphystointernal import CompuPhysToInternal
 
 
-class CompuCategory(Enum):
-    IDENTICAL = "IDENTICAL"
-    LINEAR = "LINEAR"
-    SCALE_LINEAR = "SCALE-LINEAR"
-    TEXTTABLE = "TEXTTABLE"
-    COMPUCODE = "COMPUCODE"
-    TAB_INTP = "TAB-INTP"
-    RAT_FUNC = "RAT-FUNC"
-    SCALE_RAT_FUNC = "SCALE-RAT-FUNC"
-
-
 @dataclass
 class CompuMethod:
     """A compu method translates between the internal representation
@@ -42,14 +31,14 @@ class CompuMethod:
     """
 
     category: CompuCategory
-    compu_internal_to_phys: Optional[CompuInternalToPhys]
-    compu_phys_to_internal: Optional[CompuPhysToInternal]
+    compu_internal_to_phys: CompuInternalToPhys | None
+    compu_phys_to_internal: CompuPhysToInternal | None
 
     physical_type: DataType
     internal_type: DataType
 
     @staticmethod
-    def compu_method_from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment], *,
+    def compu_method_from_et(et_element: ElementTree.Element, doc_frags: list[OdxDocFragment], *,
                              internal_type: DataType, physical_type: DataType) -> "CompuMethod":
         cat_text = et_element.findtext("CATEGORY")
         if cat_text is None:
@@ -78,7 +67,7 @@ class CompuMethod:
             physical_type=physical_type,
             internal_type=internal_type)
 
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         result = {}
 
         if self.compu_internal_to_phys is not None:

odxtools/compumethods/compuphystointernal.py

@@ -1,6 +1,6 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import Any, Dict, List, Optional
+from typing import Any
 from xml.etree import ElementTree
 
 from ..odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
@@ -13,13 +13,13 @@ from .compuscale import CompuScale
 
 @dataclass
 class CompuPhysToInternal:
-    compu_scales: List[CompuScale]
-    prog_code: Optional[ProgCode]
-    compu_default_value: Optional[CompuDefaultValue]
+    compu_scales: list[CompuScale]
+    prog_code: ProgCode | None
+    compu_default_value: CompuDefaultValue | None
 
     @staticmethod
     def compu_phys_to_internal_from_et(et_element: ElementTree.Element,
-                                       doc_frags: List[OdxDocFragment], *, internal_type: DataType,
+                                       doc_frags: list[OdxDocFragment], *, internal_type: DataType,
                                        physical_type: DataType) -> "CompuPhysToInternal":
         compu_scales = [
             CompuScale.compuscale_from_et(
@@ -39,7 +39,7 @@ class CompuPhysToInternal:
         return CompuPhysToInternal(
             compu_scales=compu_scales, prog_code=prog_code, compu_default_value=compu_default_value)
 
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         result = {}
 
         if self.prog_code is not None:

odxtools/compumethods/compurationalcoeffs.py

@@ -1,6 +1,6 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import List, Union, cast
+from typing import cast
 from xml.etree import ElementTree
 
 from ..exceptions import odxassert, odxrequire
@@ -12,11 +12,11 @@ from ..odxtypes import DataType
 class CompuRationalCoeffs:
     value_type: DataType
 
-    numerators: List[Union[int, float]]
-    denominators: List[Union[int, float]]
+    numerators: list[int | float]
+    denominators: list[int | float]
 
     @staticmethod
-    def coeffs_from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment], *,
+    def coeffs_from_et(et_element: ElementTree.Element, doc_frags: list[OdxDocFragment], *,
                        value_type: DataType) -> "CompuRationalCoeffs":
         odxassert(
             value_type

odxtools/compumethods/compuscale.py

@@ -1,6 +1,5 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import List, Optional
 from xml.etree import ElementTree
 
 from ..description import Description
@@ -17,13 +16,13 @@ class CompuScale:
     """A COMPU-SCALE represents one value range of a COMPU-METHOD.
     """
 
-    short_label: Optional[str]
-    description: Optional[Description]
-    lower_limit: Optional[Limit]
-    upper_limit: Optional[Limit]
-    compu_inverse_value: Optional[CompuInverseValue]
-    compu_const: Optional[CompuConst]
-    compu_rational_coeffs: Optional[CompuRationalCoeffs]
+    short_label: str | None
+    description: Description | None
+    lower_limit: Limit | None
+    upper_limit: Limit | None
+    compu_inverse_value: CompuInverseValue | None
+    compu_const: CompuConst | None
+    compu_rational_coeffs: CompuRationalCoeffs | None
 
     # the following two attributes are not specified for COMPU-SCALE
     # tags in the XML, but they are required to do anything useful
@@ -38,7 +37,7 @@ class CompuScale:
     range_type: DataType
 
     @staticmethod
-    def compuscale_from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment], *,
+    def compuscale_from_et(et_element: ElementTree.Element, doc_frags: list[OdxDocFragment], *,
                            domain_type: DataType, range_type: DataType) -> "CompuScale":
         short_label = et_element.findtext("SHORT-LABEL")
         description = Description.from_et(et_element.find("DESC"), doc_frags)
@@ -56,7 +55,7 @@ class CompuScale:
         if (cce := et_element.find("COMPU-CONST")) is not None:
             compu_const = CompuConst.compuvalue_from_et(cce, data_type=range_type)
 
-        compu_rational_coeffs: Optional[CompuRationalCoeffs] = None
+        compu_rational_coeffs: CompuRationalCoeffs | None = None
         if (crc_elem := et_element.find("COMPU-RATIONAL-COEFFS")) is not None:
             compu_rational_coeffs = CompuRationalCoeffs.coeffs_from_et(
                 crc_elem, doc_frags, value_type=range_type)

odxtools/compumethods/createanycompumethod.py

@@ -1,5 +1,4 @@
 # SPDX-License-Identifier: MIT
-from typing import List
 from xml.etree import ElementTree
 
 from ..exceptions import odxraise, odxrequire
@@ -17,7 +16,7 @@ from .texttablecompumethod import TexttableCompuMethod
 
 
 def create_any_compu_method_from_et(et_element: ElementTree.Element,
-                                    doc_frags: List[OdxDocFragment], *, internal_type: DataType,
+                                    doc_frags: list[OdxDocFragment], *, internal_type: DataType,
                                     physical_type: DataType) -> CompuMethod:
     compu_category = odxrequire(et_element.findtext("CATEGORY"))
 

odxtools/compumethods/identicalcompumethod.py

@@ -1,6 +1,5 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import List
 from xml.etree import ElementTree
 
 from ..exceptions import odxassert
@@ -18,7 +17,7 @@ class IdenticalCompuMethod(CompuMethod):
     """
 
     @staticmethod
-    def compu_method_from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment], *,
+    def compu_method_from_et(et_element: ElementTree.Element, doc_frags: list[OdxDocFragment], *,
                              internal_type: DataType,
                              physical_type: DataType) -> "IdenticalCompuMethod":
         cm = CompuMethod.compu_method_from_et(

odxtools/compumethods/intervaltype.py

@@ -0,0 +1,8 @@
+# SPDX-License-Identifier: MIT
+from enum import Enum
+
+
+class IntervalType(Enum):
+    OPEN = "OPEN"
+    CLOSED = "CLOSED"
+    INFINITE = "INFINITE"