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

odxtools/diaglayertype.py

@@ -20,11 +20,23 @@ class DiagLayerType(Enum):
         """
 
         PRIORITY_OF_DIAG_LAYER_TYPE: Dict[DiagLayerType, int] = {
-            DiagLayerType.ECU_SHARED_DATA: 0,
-            DiagLayerType.PROTOCOL: 1,
-            DiagLayerType.FUNCTIONAL_GROUP: 2,
-            DiagLayerType.BASE_VARIANT: 3,
-            DiagLayerType.ECU_VARIANT: 4,
+            DiagLayerType.PROTOCOL:
+                1,
+            DiagLayerType.FUNCTIONAL_GROUP:
+                2,
+            DiagLayerType.BASE_VARIANT:
+                3,
+            DiagLayerType.ECU_VARIANT:
+                4,
+
+            # ECU shared data layers are a bit weird (see section
+            # 7.3.2.4.4 of the ASAM specification): they can be
+            # inherited from by any other layer but they will
+            # override any objects which are also provided by any of
+            # the other parent layers. tl;dr: When it comes to
+            # inheritance, they have the highest priority.
+            DiagLayerType.ECU_SHARED_DATA:
+                100,
         }
 
         return PRIORITY_OF_DIAG_LAYER_TYPE[self]

odxtools/diagservice.py

@@ -167,7 +167,7 @@ class DiagService(DiagComm):
         for cpr in self.comparam_refs:
             cpr._resolve_odxlinks(odxlinks)
 
-        self._request = odxlinks.resolve(self.request_ref)
+        self._request = odxlinks.resolve(self.request_ref, Request)
 
         self._positive_responses = NamedItemList[Response](
             [odxlinks.resolve(x, Response) for x in self.pos_response_refs])

odxtools/dopbase.py

@@ -64,8 +64,10 @@ class DopBase(IdentifiableElement):
         """
         raise NotImplementedError
 
-    def convert_physical_to_bytes(self, physical_value: ParameterValue, encode_state: EncodeState,
-                                  bit_position: int) -> bytes:
+    def convert_physical_to_bytes(self,
+                                  physical_value: ParameterValue,
+                                  encode_state: EncodeState,
+                                  bit_position: int = 0) -> bytes:
         """Convert the physical value into bytes."""
         raise NotImplementedError
 

odxtools/dtcdop.py

@@ -46,8 +46,8 @@ class DtcDop(DopBase):
         compu_method = create_any_compu_method_from_et(
             odxrequire(et_element.find("COMPU-METHOD")),
             doc_frags,
-            diag_coded_type.base_data_type,
-            physical_type.base_data_type,
+            internal_type=diag_coded_type.base_data_type,
+            physical_type=physical_type.base_data_type,
         )
         dtcs_raw: List[Union[DiagnosticTroubleCode, OdxLinkRef]] = []
         if (dtcs_elem := et_element.find("DTCS")) is not None:
@@ -59,7 +59,7 @@ class DtcDop(DopBase):
 
         # TODO: NOT-INHERITED-DTC-SNREFS
         linked_dtc_dop_refs = [
-            cast(OdxLinkRef, OdxLinkRef.from_et(dtc_ref_elem, doc_frags))
+            OdxLinkRef.from_et(dtc_ref_elem, doc_frags)
             for dtc_ref_elem in et_element.iterfind("LINKED-DTC-DOPS/"
                                                     "LINKED-DTC-DOP/"
                                                     "DTC-DOP-REF")
@@ -128,8 +128,10 @@ class DtcDop(DopBase):
 
         return dtc
 
-    def convert_physical_to_bytes(self, physical_value: ParameterValue, encode_state: EncodeState,
-                                  bit_position: int) -> bytes:
+    def convert_physical_to_bytes(self,
+                                  physical_value: ParameterValue,
+                                  encode_state: EncodeState,
+                                  bit_position: int = 0) -> bytes:
         if isinstance(physical_value, DiagnosticTroubleCode):
             trouble_code = physical_value.trouble_code
         elif isinstance(physical_value, int):

odxtools/dynamiclengthfield.py

@@ -99,6 +99,7 @@ class DynamicLengthField(Field):
         decode_state.cursor_bit_position = det_num_items.bit_position or 0
 
         n = det_num_items.dop.decode_from_pdu(decode_state)
+        result: List[ParameterValue] = []
 
         if not isinstance(n, int):
             odxraise(f"Number of items specified by a dynamic length field {self.short_name} "
@@ -107,11 +108,11 @@ class DynamicLengthField(Field):
             odxraise(
                 f"Number of items specified by a dynamic length field {self.short_name} "
                 f"must be positive (is: {n})", DecodeError)
-        else:
-            decode_state.cursor_byte_position = decode_state.origin_byte_position + self.offset
-            result: List[ParameterValue] = []
-            for _ in range(n):
-                result.append(self.structure.decode_from_pdu(decode_state))
+            n = 0
+
+        decode_state.cursor_byte_position = decode_state.origin_byte_position + self.offset
+        for _ in range(n):
+            result.append(self.structure.decode_from_pdu(decode_state))
 
         decode_state.origin_byte_position = orig_origin
         decode_state.cursor_byte_position = max(orig_cursor, decode_state.cursor_byte_position)

odxtools/endofpdufield.py

@@ -41,7 +41,7 @@ class EndOfPduField(Field):
 
     def convert_physical_to_bytes(
         self,
-        physical_values: ParameterValue,
+        physical_value: ParameterValue,
         encode_state: EncodeState,
         bit_position: int = 0,
     ) -> bytes:
@@ -49,13 +49,13 @@ class EndOfPduField(Field):
         odxassert(
             bit_position == 0, "End of PDU field must be byte aligned. "
             "Is there an error in reading the .odx?", EncodeError)
-        if not isinstance(physical_values, list):
+        if not isinstance(physical_value, list):
             odxraise(
                 f"Expected a list of values for end-of-pdu field {self.short_name}, "
-                f"got {type(physical_values)}", EncodeError)
+                f"got {type(physical_value)}", EncodeError)
 
         coded_message = b''
-        for value in physical_values:
+        for value in physical_value:
             coded_message += self.structure.convert_physical_to_bytes(value, encode_state)
         return coded_message
 

odxtools/environmentdatadescription.py

@@ -86,8 +86,10 @@ class EnvironmentDataDescription(ComplexDop):
             for ed in self.env_datas:
                 ed._resolve_snrefs(diag_layer)
 
-    def convert_physical_to_bytes(self, physical_value: ParameterValue, encode_state: EncodeState,
-                                  bit_position: int) -> bytes:
+    def convert_physical_to_bytes(self,
+                                  physical_value: ParameterValue,
+                                  encode_state: EncodeState,
+                                  bit_position: int = 0) -> bytes:
         """Convert the physical value into bytes.
 
         Since environmental data is supposed to never appear on the

odxtools/inputparam.py

@@ -53,6 +53,6 @@ class InputParam(NamedElement):
         return self._dop_base
 
     @property
-    @deprecated(details="use .dop_base")
+    @deprecated(details="use .dop_base")  # type: ignore[misc]
     def dop(self) -> DopBase:
         return self._dop_base

odxtools/internalconstr.py

@@ -4,6 +4,7 @@ from typing import List, Optional
 from xml.etree import ElementTree
 
 from .compumethods.limit import Limit
+from .odxlink import OdxDocFragment
 from .odxtypes import DataType
 from .scaleconstr import ScaleConstr
 
@@ -19,16 +20,24 @@ class InternalConstr:
     upper_limit: Optional[Limit]
     scale_constrs: List[ScaleConstr]
 
+    value_type: DataType
+
     @staticmethod
-    def from_et(et_element: ElementTree.Element, internal_type: DataType) -> "InternalConstr":
+    def constr_from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment], *,
+                       value_type: DataType) -> "InternalConstr":
 
-        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)
 
         scale_constrs = [
-            ScaleConstr.from_et(sc_el, internal_type)
+            ScaleConstr.scale_constr_from_et(sc_el, doc_frags, value_type=value_type)
             for sc_el in et_element.iterfind("SCALE-CONSTRS/SCALE-CONSTR")
         ]
 
         return InternalConstr(
-            lower_limit=lower_limit, upper_limit=upper_limit, scale_constrs=scale_constrs)
+            lower_limit=lower_limit,
+            upper_limit=upper_limit,
+            scale_constrs=scale_constrs,
+            value_type=value_type)

odxtools/isotp_state_machine.py

@@ -55,10 +55,13 @@ class IsoTpStateMachine:
             return  # unknown CAN ID
 
         # decode the isotp segment
-        (frame_type,) = bitstruct.unpack("u4", data)
+        frame_type, _ = bitstruct.unpack("u4u4", data)
+        assert isinstance(frame_type, int)
+
         telegram_len = None
         if frame_type == IsoTp.FRAME_TYPE_SINGLE:
             frame_type, telegram_len = bitstruct.unpack("u4u4", data)
+            assert isinstance(telegram_len, int)
 
             self.on_single_frame(telegram_idx, data[1:1 + telegram_len])
             self.on_telegram_complete(telegram_idx, data[1:1 + telegram_len])
@@ -67,6 +70,7 @@ class IsoTpStateMachine:
 
         elif frame_type == IsoTp.FRAME_TYPE_FIRST:
             frame_type, telegram_len = bitstruct.unpack("u4u12", data)
+            assert isinstance(telegram_len, int)
 
             self._telegram_specified_len[telegram_idx] = telegram_len
             self._telegram_data[telegram_idx] = bytearray(data[2:])
@@ -76,11 +80,13 @@ class IsoTpStateMachine:
 
         elif frame_type == IsoTp.FRAME_TYPE_CONSECUTIVE:
             frame_type, rx_segment_idx = bitstruct.unpack("u4u4", data)
+            assert isinstance(rx_segment_idx, int)
 
             expected_segment_idx = (self._telegram_last_rx_fragment_idx[telegram_idx] + 1) % 16
             telegram_data = self._telegram_data[telegram_idx]
             assert isinstance(telegram_data, bytearray)
 
+            n = -1
             if expected_segment_idx == rx_segment_idx:
                 self._telegram_last_rx_fragment_idx[telegram_idx] = rx_segment_idx
                 telegram_data += data[1:]
@@ -102,6 +108,8 @@ class IsoTpStateMachine:
 
         elif frame_type == IsoTp.FRAME_TYPE_FLOW_CONTROL:
             frame_type, flow_control_flag = bitstruct.unpack("u4u4", data)
+            assert isinstance(flow_control_flag, int)
+
             self.on_flow_control_frame(telegram_idx, flow_control_flag)
         else:
             self.on_frame_type_error(telegram_idx, frame_type)
@@ -139,7 +147,7 @@ class IsoTpStateMachine:
                     return
 
                 if m := self.can_normal_frame_re.match(cur_line.strip()):
-                    #frame_interface = m.group(1)
+                    # frame_interface = m.group(1)
                     frame_id = int(m.group(2), 16)
 
                     frame_data_formatted = m.group(3).strip()
@@ -151,7 +159,7 @@ class IsoTpStateMachine:
                 elif (m := self.can_log_frame_re.match(
                         cur_line.strip())) or (m := self.can_fd_log_frame_re.match(
                             cur_line.strip())):
-                    #frame_interface = m.group(2)
+                    # frame_interface = m.group(2)
                     frame_id = int(m.group(2), 16)
 
                     frame_data_formatted = m.group(3).strip()
@@ -257,7 +265,7 @@ class IsoTpActiveDecoder(IsoTpStateMachine):
 
     def on_single_frame(self, telegram_idx: int, frame_payload: bytes) -> None:
         # send ACK
-        #rx_id = self.can_rx_id(telegram_idx)
+        # rx_id = self.can_rx_id(telegram_idx)
         tx_id = self.can_tx_id(telegram_idx)
         block_size = 0xFF
         min_separation_time = 0  # ms
@@ -276,7 +284,7 @@ class IsoTpActiveDecoder(IsoTpStateMachine):
 
     def on_first_frame(self, telegram_idx: int, frame_payload: bytes) -> None:
         # send ACK
-        #rx_id = self.can_rx_id(telegram_idx)
+        # rx_id = self.can_rx_id(telegram_idx)
         tx_id = self.can_tx_id(telegram_idx)
         block_size = 0xFF  # default value, can be overwritten later
         min_separation_time = 0  # ms
@@ -308,7 +316,7 @@ class IsoTpActiveDecoder(IsoTpStateMachine):
         # send new ACK if necessary
         block_size = self._block_size[telegram_idx]
         if block_size is not None and num_received >= block_size:
-            #rx_id = self.can_rx_id(telegram_idx)
+            # rx_id = self.can_rx_id(telegram_idx)
             tx_id = self.can_tx_id(telegram_idx)
             min_separation_time = 0  # ms
             fc_payload = bitstruct.pack(

odxtools/message.py

@@ -31,6 +31,6 @@ class Message:
         return self.param_dict[key]
 
     @property
-    @deprecated("use .coding_object")
+    @deprecated("use .coding_object")  # type: ignore[misc]
     def structure(self) -> Union["Request", "Response"]:
         return self.coding_object

odxtools/multiplexer.py

@@ -36,7 +36,8 @@ class Multiplexer(ComplexDop):
     @staticmethod
     def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "Multiplexer":
         """Reads a Multiplexer from Diag Layer."""
-        kwargs = dataclass_fields_asdict(ComplexDop.from_et(et_element, doc_frags))
+        base_obj = ComplexDop.from_et(et_element, doc_frags)
+        kwargs = dataclass_fields_asdict(base_obj)
 
         byte_position = int(et_element.findtext("BYTE-POSITION", "0"))
         switch_key = MultiplexerSwitchKey.from_et(
@@ -73,8 +74,10 @@ class Multiplexer(ComplexDop):
             odxraise("Upper and lower bounds of limits must compareable")
         return lower_limit, upper_limit
 
-    def convert_physical_to_bytes(self, physical_value: ParameterValue, encode_state: EncodeState,
-                                  bit_position: int) -> bytes:
+    def convert_physical_to_bytes(self,
+                                  physical_value: ParameterValue,
+                                  encode_state: EncodeState,
+                                  bit_position: int = 0) -> bytes:
 
         if bit_position != 0:
             raise EncodeError("Multiplexer must be aligned, i.e. bit_position=0, but "
@@ -125,22 +128,23 @@ class Multiplexer(ComplexDop):
                      f" for multiplexer '{self.short_name}')")
 
         case_value: Optional[ParameterValue] = None
-        for case in self.cases or []:
-            lower, upper = self._get_case_limits(case)
+        mux_case = None
+        for mux_case in self.cases or []:
+            lower, upper = self._get_case_limits(mux_case)
             if lower <= key_value and key_value <= upper:  # type: ignore[operator]
-                if case._structure:
-                    case_value = case._structure.decode_from_pdu(decode_state)
+                if mux_case._structure:
+                    case_value = mux_case._structure.decode_from_pdu(decode_state)
                 break
 
         if case_value is None and self.default_case is not None:
             if self.default_case._structure:
                 case_value = self.default_case._structure.decode_from_pdu(decode_state)
 
-        if case_value is None:
+        if mux_case is None or case_value is None:
             odxraise(f"Failed to find a matching case in {self.short_name} for value {key_value!r}",
                      DecodeError)
 
-        mux_value = (case.short_name, case_value)
+        mux_value = (mux_case.short_name, case_value)
 
         # go back to the original origin
         decode_state.origin_byte_position = orig_origin
@@ -164,8 +168,9 @@ class Multiplexer(ComplexDop):
         if self.default_case is not None:
             self.default_case._resolve_odxlinks(odxlinks)
 
-        for case in self.cases:
-            case._resolve_odxlinks(odxlinks)
+        for mux_case in self.cases:
+            mux_case._mux_case_resolve_odxlinks(
+                odxlinks, key_physical_type=self.switch_key.dop.physical_type.base_data_type)
 
     def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
         super()._resolve_snrefs(diag_layer)
@@ -174,5 +179,5 @@ class Multiplexer(ComplexDop):
         if self.default_case is not None:
             self.default_case._resolve_snrefs(diag_layer)
 
-        for case in self.cases:
-            case._resolve_snrefs(diag_layer)
+        for mux_case in self.cases:
+            mux_case._resolve_snrefs(diag_layer)

odxtools/multiplexercase.py

@@ -4,9 +4,11 @@ from typing import TYPE_CHECKING, Any, Dict, List, Optional
 from xml.etree import ElementTree
 
 from .basicstructure import BasicStructure
+from .compumethods.limit import Limit
 from .element import NamedElement
 from .exceptions import odxrequire
 from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef
+from .odxtypes import AtomicOdxType, DataType
 from .utils import dataclass_fields_asdict
 
 if TYPE_CHECKING:
@@ -19,8 +21,8 @@ class MultiplexerCase(NamedElement):
 
     structure_ref: Optional[OdxLinkRef]
     structure_snref: Optional[str]
-    lower_limit: str
-    upper_limit: str
+    lower_limit: Limit
+    upper_limit: Limit
 
     def __post_init__(self) -> None:
         self._structure: BasicStructure
@@ -28,15 +30,23 @@ class MultiplexerCase(NamedElement):
     @staticmethod
     def from_et(et_element: ElementTree.Element,
                 doc_frags: List[OdxDocFragment]) -> "MultiplexerCase":
-        """Reads a Case for a Multiplexer."""
+        """Reads a case for a Multiplexer."""
         kwargs = dataclass_fields_asdict(NamedElement.from_et(et_element, doc_frags))
         structure_ref = OdxLinkRef.from_et(et_element.find("STRUCTURE-REF"), doc_frags)
         structure_snref = None
         if (structure_snref_elem := et_element.find("STRUCTURE-SNREF")) is not None:
             structure_snref = odxrequire(structure_snref_elem.get("SHORT-NAME"))
 
-        lower_limit = odxrequire(et_element.findtext("LOWER-LIMIT"))
-        upper_limit = odxrequire(et_element.findtext("UPPER-LIMIT"))
+        lower_limit = Limit.limit_from_et(
+            odxrequire(et_element.find("LOWER-LIMIT")),
+            doc_frags,
+            value_type=None,
+        )
+        upper_limit = Limit.limit_from_et(
+            odxrequire(et_element.find("UPPER-LIMIT")),
+            doc_frags,
+            value_type=None,
+        )
 
         return MultiplexerCase(
             structure_ref=structure_ref,
@@ -49,14 +59,26 @@ class MultiplexerCase(NamedElement):
         return {}
 
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
+        raise RuntimeError("Calling MultiplexerCase._resolve_odxlinks() is not allowed. "
+                           "Use ._mux_case_resolve_odxlinks()().")
+
+    def _mux_case_resolve_odxlinks(self, odxlinks: OdxLinkDatabase, *,
+                                   key_physical_type: DataType) -> None:
         if self.structure_ref:
             self._structure = odxlinks.resolve(self.structure_ref)
 
+        self.lower_limit.set_value_type(key_physical_type)
+        self.upper_limit.set_value_type(key_physical_type)
+
     def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
         if self.structure_snref:
             ddds = diag_layer.diag_data_dictionary_spec
             self._structure = odxrequire(ddds.structures.get(self.structure_snref))
 
+    def applies(self, value: AtomicOdxType) -> bool:
+        return self.lower_limit.complies_to_lower(value) \
+            and self.upper_limit.complies_to_upper(value)
+
     @property
     def structure(self) -> BasicStructure:
         return self._structure

odxtools/multiplexerswitchkey.py

@@ -7,7 +7,7 @@ from .exceptions import odxrequire
 from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef
 
 if TYPE_CHECKING:
-    from ..diaglayer import DiagLayer
+    from .diaglayer import DiagLayer
 
 
 @dataclass

odxtools/nameditemlist.py

@@ -12,7 +12,7 @@ class OdxNamed(Protocol):
 
     @property
     def short_name(self) -> str:
-        pass
+        ...
 
 
 T = TypeVar("T")
@@ -127,7 +127,7 @@ class ItemAttributeList(List[T]):
         result.update(self._item_dict)
         return result
 
-    @overload  # type: ignore[override]
+    @overload
     def __getitem__(self, key: SupportsIndex) -> T:
         ...
 
@@ -139,7 +139,8 @@ class ItemAttributeList(List[T]):
     def __getitem__(self, key: slice) -> List[T]:
         ...
 
-    def __getitem__(self, key: Union[SupportsIndex, str, slice]) -> Union[T, List[T]]:
+    def __getitem__(  # type: ignore
+            self, key: Union[SupportsIndex, str, slice]) -> Union[T, List[T]]:
         if isinstance(key, (SupportsIndex, slice)):
             return super().__getitem__(key)
         else:
@@ -177,7 +178,7 @@ class ItemAttributeList(List[T]):
 
 class NamedItemList(ItemAttributeList[T]):
 
-    def _get_item_key(self, obj: T) -> str:
+    def _get_item_key(self, item: T) -> str:
         """Transform an object's `short_name` attribute into a valid
         python identifier
 
@@ -187,9 +188,9 @@ class NamedItemList(ItemAttributeList[T]):
         such short names.
 
         """
-        if not isinstance(obj, OdxNamed):
+        if not isinstance(item, OdxNamed):
             odxraise()
-        sn = obj.short_name
+        sn = item.short_name
         if not isinstance(sn, str):
             odxraise()
 

odxtools/odxlink.py

@@ -181,7 +181,7 @@ class OdxLinkDatabase:
     def resolve(self, ref: OdxLinkRef, expected_type: Type[T]) -> T:
         ...
 
-    def resolve(self, ref: OdxLinkRef, expected_type: Optional[Type[T]] = None) -> Any:
+    def resolve(self, ref: OdxLinkRef, expected_type: Optional[Any] = None) -> Any:
         """
         Resolve a reference to an object
 
@@ -223,7 +223,7 @@ class OdxLinkDatabase:
 
     def resolve_lenient(self,
                         ref: OdxLinkRef,
-                        expected_type: Optional[Type[T]] = None) -> Optional[Any]:
+                        expected_type: Optional[Any] = None) -> Optional[Any]:
         """
         Resolve a reference to an object
 

odxtools/odxtypes.py

@@ -102,6 +102,58 @@ _ODX_TYPE_TO_PYTHON_TYPE: Dict[str, Type[AtomicOdxType]] = {
 }
 
 
+def compare_odx_values(a: AtomicOdxType, b: AtomicOdxType) -> int:
+    # this function implements the comparison according to the ODX
+    # specification. (cf section 7.3.6.5)
+
+    # numeric values are compared numerically (duh!)
+    if isinstance(a, (int, float)):
+        if not isinstance(b, (int, float)):
+            odxraise()
+
+        tmp = a - b
+        if tmp < 0:
+            return -1
+        elif tmp > 0:
+            return 1
+        return 0
+
+    # strings are compared lexicographically. (the spec only allows
+    # equals, but this cannot easily implemented using a single
+    # comparison function.
+    if isinstance(a, str):
+        if not isinstance(b, str):
+            odxraise()
+
+        if a < b:
+            return -1
+        elif b < a:
+            return 1
+        else:
+            return 0
+
+    # bytefields are treated like long integers: to pad the shorter
+    # object with zeros and treat the results like strings.
+    if isinstance(a, (bytes, bytearray)):
+        if not isinstance(b, (bytes, bytearray)):
+            odxraise()
+
+        obj_len = max(len(a), len(b))
+
+        tmp_a = a.ljust(obj_len, b'\x00')
+        tmp_b = b.ljust(obj_len, b'\x00')
+
+        if tmp_a > tmp_b:
+            return 1
+        elif tmp_a < tmp_b:
+            return -1
+        else:
+            return 0
+
+    odxraise(f"Unhandled comparsion between objects of type {type(a).__name__} "
+             f"and {type(b).__name__}")
+
+
 class DataType(Enum):
     """Types for the physical and internal value.
 
@@ -125,7 +177,8 @@ class DataType(Enum):
     A_ASCIISTRING = "A_ASCIISTRING"
     A_UTF8STRING = "A_UTF8STRING"
 
-    def as_python_type(self) -> type:
+    @property
+    def python_type(self) -> Type[AtomicOdxType]:
         return _ODX_TYPE_TO_PYTHON_TYPE[self.value]
 
     def from_string(self, value: str) -> AtomicOdxType:
@@ -158,10 +211,10 @@ class DataType(Enum):
             return self.from_string(value)
         else:
             # regular type cast of python objects
-            return self.as_python_type()(value)
+            return self.python_type(value)
 
     def isinstance(self, value: Any) -> bool:
-        expected_type = self.as_python_type()
+        expected_type = self.python_type
         if isinstance(value, expected_type):
             return True
         elif expected_type == float and isinstance(value, (int, float)):

odxtools/outputparam.py

@@ -35,7 +35,7 @@ class OutputParam(IdentifiableElement):
         return {}
 
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
-        self._dop_base = odxlinks.resolve(self.dop_base_ref)
+        self._dop_base = odxlinks.resolve(self.dop_base_ref, DopBase)
 
     def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
         pass
@@ -46,6 +46,6 @@ class OutputParam(IdentifiableElement):
         return self._dop_base
 
     @property
-    @deprecated(details="use .dop_base")
+    @deprecated(details="use .dop_base")  # type: ignore[misc]
     def dop(self) -> DopBase:
         return self._dop_base

odxtools/parameterinfo.py

@@ -84,11 +84,18 @@ def parameter_info(param_list: Iterable[Union[Parameter, EndOfPduField]]) -> str
             result += f": float\n"
             ll = cm.physical_lower_limit
             ul = cm.physical_upper_limit
-            result += (f" range: "
-                       f"{'[' if ll.interval_type == IntervalType.CLOSED else '('}"
-                       f"{ll.value!r}, "
-                       f"{ul.value!r}"
-                       f"{']' if ul.interval_type == IntervalType.CLOSED else ')'}\n")
+            if ll is None:
+                ll_str = "(inf"
+            else:
+                ll_delim = '[' if ll.interval_type == IntervalType.CLOSED else '('
+                ll_str = f"{ll_delim}{ll._value!r}"
+
+            if ul is None:
+                ul_str = "inf)"
+            else:
+                ul_delim = ']' if ul.interval_type == IntervalType.CLOSED else ')'
+                ul_str = f"{ul._value!r}{ul_delim}"
+            result += f" range: {ll_str}, {ul_str}\n"
 
             unit = dop.unit
             unit_str = unit.display_name if unit is not None else None