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

odxtools/dyndefinedspec.py

@@ -4,7 +4,7 @@ from typing import Any, Dict, List, Optional, Union
 from xml.etree import ElementTree
 
 from .diagcomm import DiagClassType, DiagComm
-from .exceptions import odxraise, odxrequire
+from .exceptions import odxassert, odxraise, odxrequire
 from .nameditemlist import NamedItemList
 from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef, resolve_snref
 from .snrefcontext import SnRefContext
@@ -50,17 +50,20 @@ class DynIdDefModeInfo:
 
         clear_dyn_def_message_ref = OdxLinkRef.from_et(
             et_element.find("CLEAR-DYN-DEF-MESSAGE-REF"), doc_frags)
+        clear_dyn_def_message_snref = None
         if (snref_elem := et_element.find("CLEAR-DYN-DEF-MESSAGE-SNREF")) is not None:
-            clear_dyn_def_message_snref = snref_elem.attrib["SHORT-NAME"]
+            clear_dyn_def_message_snref = odxrequire(snref_elem.attrib.get("SHORT-NAME"))
 
         read_dyn_def_message_ref = OdxLinkRef.from_et(
             et_element.find("READ-DYN-DEF-MESSAGE-REF"), doc_frags)
+        read_dyn_def_message_snref = None
         if (snref_elem := et_element.find("READ-DYN-DEF-MESSAGE-SNREF")) is not None:
-            read_dyn_def_message_snref = snref_elem.attrib["SHORT-NAME"]
+            read_dyn_def_message_snref = odxrequire(snref_elem.attrib.get("SHORT-NAME"))
 
         dyn_def_message_ref = OdxLinkRef.from_et(et_element.find("DYN-DEF-MESSAGE-REF"), doc_frags)
+        dyn_def_message_snref = None
         if (snref_elem := et_element.find("DYN-DEF-MESSAGE-SNREF")) is not None:
-            dyn_def_message_snref = snref_elem.attrib["SHORT-NAME"]
+            dyn_def_message_snref = odxrequire(snref_elem.attrib.get("SHORT-NAME"))
 
         supported_dyn_ids = [
             bytes.fromhex(odxrequire(x.text))
@@ -89,14 +92,23 @@ class DynIdDefModeInfo:
             selection_table_refs=selection_table_refs,
         )
 
+    def __post_init__(self) -> None:
+        odxassert(
+            self.clear_dyn_def_message_ref is not None or
+            self.clear_dyn_def_message_snref is not None,
+            "A CLEAR-DYN-DEF-MESSAGE must be specified")
+        odxassert(
+            self.read_dyn_def_message_ref is not None or
+            self.read_dyn_def_message_snref is not None, "A READ-DYN-DEF-MESSAGE must be specified")
+        odxassert(self.dyn_def_message_ref is not None or self.dyn_def_message_snref is not None,
+                  "A DYN-DEF-MESSAGE must be specified")
+
     def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
         result: Dict[OdxLinkId, Any] = {}
 
         return result
 
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
-        self._selection_tables = NamedItemList[Table]()
-
         if self.clear_dyn_def_message_ref is not None:
             self._clear_dyn_def_message = odxlinks.resolve(self.clear_dyn_def_message_ref, DiagComm)
 
@@ -106,7 +118,8 @@ class DynIdDefModeInfo:
         if self.dyn_def_message_ref is not None:
             self._dyn_def_message = odxlinks.resolve(self.dyn_def_message_ref, DiagComm)
 
-        # resolve the selection tables referenced using ODXLINK
+        # resolve the selection tables that are referenced via ODXLINK
+        self._selection_tables = NamedItemList[Table]()
         for x in self.selection_table_refs:
             if isinstance(x, OdxLinkRef):
                 self._selection_tables.append(odxlinks.resolve(x, Table))
@@ -141,9 +154,9 @@ class DynIdDefModeInfo:
                      f"DYN-DEF-MESSAGE)")
 
         # resolve the remaining selection tables that are referenced via SNREF
+        ddd_spec = odxrequire(diag_layer.diag_data_dictionary_spec)
         for i, x in enumerate(self.selection_table_refs):
             if isinstance(x, str):
-                ddd_spec = odxrequire(diag_layer.diag_data_dictionary_spec)
                 self._selection_tables.insert(i, resolve_snref(x, ddd_spec.tables, Table))
 
 

odxtools/encodestate.py

@@ -5,8 +5,7 @@ from typing import TYPE_CHECKING, Dict, List, Optional, Tuple
 
 from .encoding import Encoding, get_string_encoding
 from .exceptions import EncodeError, OdxWarning, odxassert, odxraise
-from .odxtypes import AtomicOdxType, DataType, ParameterValue
-from .utils import BytesTypes
+from .odxtypes import AtomicOdxType, BytesTypes, DataType, ParameterValue
 
 try:
     import bitstruct.c as bitstruct

odxtools/endofpdufield.py

@@ -17,30 +17,28 @@ from .utils import dataclass_fields_asdict
 @dataclass
 class EndOfPduField(Field):
     """End of PDU fields are structures that are repeated until the end of the PDU"""
-    min_number_of_items: Optional[int]
     max_number_of_items: Optional[int]
+    min_number_of_items: Optional[int]
 
     @staticmethod
     def from_et(et_element: ElementTree.Element,
                 doc_frags: List[OdxDocFragment]) -> "EndOfPduField":
         kwargs = dataclass_fields_asdict(Field.from_et(et_element, doc_frags))
 
-        if (min_n_str := et_element.findtext("MIN-NUMBER-OF-ITEMS")) is not None:
-            min_number_of_items = int(min_n_str)
-        else:
-            min_number_of_items = None
         if (max_n_str := et_element.findtext("MAX-NUMBER-OF-ITEMS")) is not None:
             max_number_of_items = int(max_n_str)
         else:
             max_number_of_items = None
+        if (min_n_str := et_element.findtext("MIN-NUMBER-OF-ITEMS")) is not None:
+            min_number_of_items = int(min_n_str)
+        else:
+            min_number_of_items = None
 
-        eopf = EndOfPduField(
-            min_number_of_items=min_number_of_items,
+        return EndOfPduField(
             max_number_of_items=max_number_of_items,
+            min_number_of_items=min_number_of_items,
             **kwargs)
 
-        return eopf
-
     @override
     def encode_into_pdu(self, physical_value: Optional[ParameterValue],
                         encode_state: EncodeState) -> None:

odxtools/environmentdatadescription.py

@@ -1,6 +1,6 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import Any, Dict, List, Optional, cast
+from typing import Any, Dict, List, Optional
 from xml.etree import ElementTree
 
 from typing_extensions import override
@@ -44,18 +44,6 @@ class EnvironmentDataDescription(ComplexDop):
     env_datas: NamedItemList[EnvironmentData]
     env_data_refs: List[OdxLinkRef]
 
-    @property
-    def param(self) -> Parameter:
-        # the parameter referenced via SNREF cannot be resolved here
-        # because the relevant list of parameters depends on the
-        # concrete codec object processed, whilst an environment data
-        # description object can be featured in an arbitrary number of
-        # responses. Instead, lookup of the appropriate parameter is
-        # done within the encode and decode methods.
-        odxraise("The parameter of ENV-DATA-DESC objects cannot be resolved "
-                 "because it depends on the context")
-        return cast(None, Parameter)
-
     @staticmethod
     def from_et(et_element: ElementTree.Element,
                 doc_frags: List[OdxDocFragment]) -> "EnvironmentDataDescription":
@@ -74,20 +62,20 @@ class EnvironmentDataDescription(ComplexDop):
         # situation is reversed. This means that we will create one
         # empty and one non-empty list here. (Which is which depends
         # on the version of the standard used by the file.)
-        env_data_refs = [
-            odxrequire(OdxLinkRef.from_et(env_data_ref, doc_frags))
-            for env_data_ref in et_element.iterfind("ENV-DATA-REFS/ENV-DATA-REF")
-        ]
         env_datas = NamedItemList([
             EnvironmentData.from_et(env_data_elem, doc_frags)
             for env_data_elem in et_element.iterfind("ENV-DATAS/ENV-DATA")
         ])
+        env_data_refs = [
+            odxrequire(OdxLinkRef.from_et(env_data_ref, doc_frags))
+            for env_data_ref in et_element.iterfind("ENV-DATA-REFS/ENV-DATA-REF")
+        ]
 
         return EnvironmentDataDescription(
             param_snref=param_snref,
             param_snpathref=param_snpathref,
-            env_data_refs=env_data_refs,
             env_datas=env_datas,
+            env_data_refs=env_data_refs,
             **kwargs)
 
     def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
@@ -103,7 +91,8 @@ class EnvironmentDataDescription(ComplexDop):
         # ODX 2.0 specifies environment data objects here, ODX 2.2
         # uses references
         if self.env_data_refs:
-            self.env_datas = NamedItemList([odxlinks.resolve(x) for x in self.env_data_refs])
+            self.env_datas = NamedItemList(
+                [odxlinks.resolve(x, EnvironmentData) for x in self.env_data_refs])
         else:
             for ed in self.env_datas:
                 ed._resolve_odxlinks(odxlinks)
@@ -221,7 +210,7 @@ class EnvironmentDataDescription(ComplexDop):
             if not isinstance(dop, (DataObjectProperty, DtcDop)):
                 odxraise(f"The DOP of the parameter referenced by environment data descriptions "
                          f"must use either be DataObjectProperty or a DtcDop (encountered "
-                         f"{type(param).__name__} for parameter '{self.param.short_name}' "
+                         f"{type(param).__name__} for parameter '{param.short_name}' "
                          f"of ENV-DATA-DESC '{self.short_name}')")
                 return 0
 

odxtools/field.py

@@ -21,19 +21,14 @@ class Field(ComplexDop):
     env_data_desc_snref: Optional[str]
     is_visible_raw: Optional[bool]
 
-    def __post_init__(self) -> None:
-        self._structure: Optional[BasicStructure] = None
-        self._env_data_desc: Optional[EnvironmentDataDescription] = None
-        num_struct_refs = 0 if self.structure_ref is None else 1
-        num_struct_refs += 0 if self.structure_snref is None else 1
-
-        num_edd_refs = 0 if self.env_data_desc_ref is None else 1
-        num_edd_refs += 0 if self.env_data_desc_snref is None else 1
+    @property
+    def structure(self) -> BasicStructure:
+        """may be a Structure or a env-data-desc"""
+        return odxrequire(self._structure, "EnvironmentDataDescription is not supported")
 
-        odxassert(
-            num_struct_refs + num_edd_refs == 1,
-            "FIELDs need to specify exactly one reference to a "
-            "structure or an environment data description")
+    @property
+    def is_visible(self) -> bool:
+        return self.is_visible_raw in (None, True)
 
     @staticmethod
     def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "Field":
@@ -58,17 +53,19 @@ class Field(ComplexDop):
             is_visible_raw=is_visible_raw,
             **kwargs)
 
-    @property
-    def is_visible(self) -> bool:
-        return self.is_visible_raw in (None, True)
+    def __post_init__(self) -> None:
+        self._structure: Optional[BasicStructure] = None
+        self._env_data_desc: Optional[EnvironmentDataDescription] = None
+        num_struct_refs = 0 if self.structure_ref is None else 1
+        num_struct_refs += 0 if self.structure_snref is None else 1
 
-    @property
-    def structure(self) -> BasicStructure:
-        """may be a Structure or a env-data-desc"""
-        return odxrequire(self._structure, "EnvironmentDataDescription is not supported")
+        num_edd_refs = 0 if self.env_data_desc_ref is None else 1
+        num_edd_refs += 0 if self.env_data_desc_snref is None else 1
 
-    def get_static_bit_length(self) -> Optional[int]:
-        return None
+        odxassert(
+            num_struct_refs + num_edd_refs == 1,
+            "FIELDs need to specify exactly one reference to a "
+            "structure or an environment data description")
 
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
         """Recursively resolve any odxlinks references"""
@@ -89,3 +86,6 @@ class Field(ComplexDop):
         if self.env_data_desc_snref is not None:
             self._env_data_desc = resolve_snref(self.env_data_desc_snref, ddds.env_data_descs,
                                                 EnvironmentDataDescription)
+
+    def get_static_bit_length(self) -> Optional[int]:
+        return None

odxtools/inputparam.py

@@ -15,25 +15,35 @@ from .utils import dataclass_fields_asdict
 
 @dataclass
 class InputParam(NamedElement):
+    physical_default_value: Optional[str]
     dop_base_ref: OdxLinkRef
     oid: Optional[str]
     semantic: Optional[str]
-    physical_default_value: Optional[str]
+
+    @property
+    def dop(self) -> DopBase:
+        """The data object property describing this parameter."""
+        return self._dop
+
+    @deprecated(details="use .dop")  # type: ignore[misc]
+    def dop_base(self) -> DopBase:
+        return self._dop
 
     @staticmethod
     def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "InputParam":
         kwargs = dataclass_fields_asdict(NamedElement.from_et(et_element, doc_frags))
-        dop_base_ref = odxrequire(OdxLinkRef.from_et(et_element.find("DOP-BASE-REF"), doc_frags))
+
         physical_default_value = et_element.findtext("PHYSICAL-DEFAULT-VALUE")
+        dop_base_ref = odxrequire(OdxLinkRef.from_et(et_element.find("DOP-BASE-REF"), doc_frags))
 
-        semantic = et_element.get("SEMANTIC")
         oid = et_element.get("OID")
+        semantic = et_element.get("SEMANTIC")
 
         return InputParam(
-            dop_base_ref=dop_base_ref,
             physical_default_value=physical_default_value,
-            semantic=semantic,
+            dop_base_ref=dop_base_ref,
             oid=oid,
+            semantic=semantic,
             **kwargs)
 
     def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
@@ -44,12 +54,3 @@ class InputParam(NamedElement):
 
     def _resolve_snrefs(self, context: SnRefContext) -> None:
         pass
-
-    @property
-    def dop(self) -> DopBase:
-        """The data object property describing this parameter."""
-        return self._dop
-
-    @deprecated(details="use .dop")  # type: ignore[misc]
-    def dop_base(self) -> DopBase:
-        return self._dop

odxtools/leadinglengthinfotype.py

@@ -23,6 +23,10 @@ class LeadingLengthInfoType(DiagCodedType):
     #: object.
     bit_length: int
 
+    @property
+    def dct_type(self) -> DctType:
+        return "LEADING-LENGTH-INFO-TYPE"
+
     @staticmethod
     @override
     def from_et(et_element: ElementTree.Element,
@@ -46,10 +50,6 @@ class LeadingLengthInfoType(DiagCodedType):
             f"A leading length info type cannot have the base data type {self.base_data_type.name}."
         )
 
-    @property
-    def dct_type(self) -> DctType:
-        return "LEADING-LENGTH-INFO-TYPE"
-
     @override
     def encode_into_pdu(self, internal_value: AtomicOdxType, encode_state: EncodeState) -> None:
 

odxtools/matchingparameter.py

@@ -8,9 +8,8 @@ from .diagnostictroublecode import DiagnosticTroubleCode
 from .diagservice import DiagService
 from .exceptions import odxraise, odxrequire
 from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, resolve_snref
-from .odxtypes import ParameterValue, ParameterValueDict
+from .odxtypes import BytesTypes, ParameterValue, ParameterValueDict
 from .snrefcontext import SnRefContext
-from .utils import BytesTypes
 
 
 @dataclass
@@ -53,7 +52,7 @@ class MatchingParameter:
         elif (out_param_snpathref_el := et_element.find("OUT-PARAM-IF-SNPATHREF")) is not None:
             out_param_if_snpathref = odxrequire(out_param_snpathref_el.get("SHORT-NAME-PATH"))
         else:
-            odxraise("Output parameter must not left unspecified")
+            odxraise("Output parameter must not be left unspecified")
 
         return MatchingParameter(
             expected_value=expected_value,

odxtools/minmaxlengthtype.py

@@ -10,10 +10,10 @@ from .decodestate import DecodeState
 from .diagcodedtype import DctType, DiagCodedType
 from .encodestate import EncodeState
 from .encoding import get_string_encoding
-from .exceptions import (DecodeError, EncodeError, odxassert, odxraise, odxrequire)
+from .exceptions import DecodeError, EncodeError, odxassert, odxraise, odxrequire
 from .odxlink import OdxDocFragment
-from .odxtypes import AtomicOdxType, DataType
-from .utils import BytesTypes, dataclass_fields_asdict
+from .odxtypes import AtomicOdxType, BytesTypes, DataType
+from .utils import dataclass_fields_asdict
 
 
 class Termination(Enum):
@@ -24,8 +24,8 @@ class Termination(Enum):
 
 @dataclass
 class MinMaxLengthType(DiagCodedType):
-    min_length: int
     max_length: Optional[int]
+    min_length: int
     termination: Termination
 
     @property
@@ -38,12 +38,12 @@ class MinMaxLengthType(DiagCodedType):
                 doc_frags: List[OdxDocFragment]) -> "MinMaxLengthType":
         kwargs = dataclass_fields_asdict(DiagCodedType.from_et(et_element, doc_frags))
 
-        min_length = int(odxrequire(et_element.findtext("MIN-LENGTH")))
         max_length = None
         if et_element.find("MAX-LENGTH") is not None:
             max_length = int(odxrequire(et_element.findtext("MAX-LENGTH")))
+        min_length = int(odxrequire(et_element.findtext("MIN-LENGTH")))
 
-        termination_str = odxrequire(et_element.get("TERMINATION"))
+        termination_str = odxrequire(et_element.attrib.get("TERMINATION"))
         try:
             termination = Termination(termination_str)
         except ValueError:
@@ -51,7 +51,7 @@ class MinMaxLengthType(DiagCodedType):
             odxraise(f"Encountered unknown termination type '{termination_str}'")
 
         return MinMaxLengthType(
-            min_length=min_length, max_length=max_length, termination=termination, **kwargs)
+            max_length=max_length, min_length=min_length, termination=termination, **kwargs)
 
     def __post_init__(self) -> None:
         odxassert(self.max_length is None or self.min_length <= self.max_length)

odxtools/multiplexer.py

@@ -34,12 +34,15 @@ class Multiplexer(ComplexDop):
     cases: NamedItemList[MultiplexerCase]
     is_visible_raw: Optional[bool]
 
+    @property
+    def is_visible(self) -> bool:
+        return self.is_visible_raw is True
+
     @staticmethod
     @override
     def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "Multiplexer":
         """Reads a Multiplexer from Diag Layer."""
-        base_obj = ComplexDop.from_et(et_element, doc_frags)
-        kwargs = dataclass_fields_asdict(base_obj)
+        kwargs = dataclass_fields_asdict(ComplexDop.from_et(et_element, doc_frags))
 
         byte_position = int(et_element.findtext("BYTE-POSITION", "0"))
         switch_key = MultiplexerSwitchKey.from_et(
@@ -55,16 +58,45 @@ class Multiplexer(ComplexDop):
         is_visible_raw = odxstr_to_bool(et_element.get("IS-VISIBLE"))
 
         return Multiplexer(
-            is_visible_raw=is_visible_raw,
             byte_position=byte_position,
             switch_key=switch_key,
             default_case=default_case,
             cases=cases,
+            is_visible_raw=is_visible_raw,
             **kwargs)
 
-    @property
-    def is_visible(self) -> bool:
-        return self.is_visible_raw is True
+    @override
+    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+        odxlinks = super()._build_odxlinks()
+
+        odxlinks.update(self.switch_key._build_odxlinks())
+        if self.default_case is not None:
+            odxlinks.update(self.default_case._build_odxlinks())
+
+        return odxlinks
+
+    @override
+    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
+        super()._resolve_odxlinks(odxlinks)
+
+        self.switch_key._resolve_odxlinks(odxlinks)
+        if self.default_case is not None:
+            self.default_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)
+
+    @override
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
+        super()._resolve_snrefs(context)
+
+        self.switch_key._resolve_snrefs(context)
+        if self.default_case is not None:
+            self.default_case._resolve_snrefs(context)
+
+        for mux_case in self.cases:
+            mux_case._resolve_snrefs(context)
 
     def _get_case_limits(self, case: MultiplexerCase) -> Tuple[AtomicOdxType, AtomicOdxType]:
         key_type = self.switch_key.dop.physical_type.base_data_type
@@ -203,36 +235,3 @@ class Multiplexer(ComplexDop):
         decode_state.origin_byte_position = orig_origin
 
         return result
-
-    @override
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
-        odxlinks = super()._build_odxlinks()
-
-        odxlinks.update(self.switch_key._build_odxlinks())
-        if self.default_case is not None:
-            odxlinks.update(self.default_case._build_odxlinks())
-
-        return odxlinks
-
-    @override
-    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
-        super()._resolve_odxlinks(odxlinks)
-
-        self.switch_key._resolve_odxlinks(odxlinks)
-        if self.default_case is not None:
-            self.default_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)
-
-    @override
-    def _resolve_snrefs(self, context: SnRefContext) -> None:
-        super()._resolve_snrefs(context)
-
-        self.switch_key._resolve_snrefs(context)
-        if self.default_case is not None:
-            self.default_case._resolve_snrefs(context)
-
-        for mux_case in self.cases:
-            mux_case._resolve_snrefs(context)

odxtools/multiplexercase.py

@@ -22,8 +22,9 @@ class MultiplexerCase(NamedElement):
     lower_limit: Limit
     upper_limit: Limit
 
-    def __post_init__(self) -> None:
-        self._structure: Optional[Structure]
+    @property
+    def structure(self) -> Optional[Structure]:
+        return self._structure
 
     @staticmethod
     def from_et(et_element: ElementTree.Element,
@@ -77,7 +78,3 @@ class MultiplexerCase(NamedElement):
     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) -> Optional[Structure]:
-        return self._structure

odxtools/multiplexerdefaultcase.py

@@ -17,8 +17,9 @@ class MultiplexerDefaultCase(NamedElement):
     structure_ref: Optional[OdxLinkRef]
     structure_snref: Optional[str]
 
-    def __post_init__(self) -> None:
-        self._structure: Optional[Structure]
+    @property
+    def structure(self) -> Optional[Structure]:
+        return self._structure
 
     @staticmethod
     def from_et(et_element: ElementTree.Element,
@@ -46,7 +47,3 @@ class MultiplexerDefaultCase(NamedElement):
         if self.structure_snref:
             ddds = odxrequire(context.diag_layer).diag_data_dictionary_spec
             self._structure = resolve_snref(self.structure_snref, ddds.structures, Structure)
-
-    @property
-    def structure(self) -> Optional[Structure]:
-        return self._structure

odxtools/multiplexerswitchkey.py

@@ -18,6 +18,10 @@ class MultiplexerSwitchKey:
     bit_position: Optional[int]
     dop_ref: OdxLinkRef
 
+    @property
+    def dop(self) -> DataObjectProperty:
+        return self._dop
+
     @staticmethod
     def from_et(et_element: ElementTree.Element,
                 doc_frags: List[OdxDocFragment]) -> "MultiplexerSwitchKey":
@@ -40,7 +44,3 @@ class MultiplexerSwitchKey:
 
     def _resolve_snrefs(self, context: SnRefContext) -> None:
         pass
-
-    @property
-    def dop(self) -> DataObjectProperty:
-        return self._dop

odxtools/negoutputparam.py

@@ -1,6 +1,6 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import Any, Dict, List, Optional
+from typing import Any, Dict, List
 from xml.etree import ElementTree
 
 from .dopbase import DopBase
@@ -15,8 +15,10 @@ from .utils import dataclass_fields_asdict
 class NegOutputParam(NamedElement):
     dop_base_ref: OdxLinkRef
 
-    def __post_init__(self) -> None:
-        self._dop: Optional[DopBase] = None
+    @property
+    def dop(self) -> DopBase:
+        """The data object property describing this parameter."""
+        return self._dop
 
     @staticmethod
     def from_et(et_element: ElementTree.Element,
@@ -31,12 +33,7 @@ class NegOutputParam(NamedElement):
         return {}
 
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
-        self._dop = odxlinks.resolve(self.dop_base_ref)
+        self._dop = odxlinks.resolve(self.dop_base_ref, DopBase)
 
     def _resolve_snrefs(self, context: SnRefContext) -> None:
         pass
-
-    @property
-    def dop(self) -> Optional[DopBase]:
-        """The data object property describing this parameter."""
-        return self._dop

odxtools/odxlink.py

@@ -277,24 +277,40 @@ class OdxLinkDatabase:
 @overload
 def resolve_snref(target_short_name: str,
                   items: Iterable[OdxNamed],
-                  expected_type: None = None) -> Any:
+                  expected_type: None = None,
+                  *,
+                  lenient: None = None) -> Any:
     """Resolve a short name reference given a sequence of candidate objects"""
     ...
 
 
 @overload
-def resolve_snref(target_short_name: str, items: Iterable[OdxNamed],
-                  expected_type: Type[TNamed]) -> TNamed:
+def resolve_snref(target_short_name: str,
+                  items: Iterable[OdxNamed],
+                  expected_type: Type[TNamed],
+                  *,
+                  lenient: None = None) -> TNamed:
+    ...
+
+
+@overload
+def resolve_snref(target_short_name: str,
+                  items: Iterable[OdxNamed],
+                  expected_type: Type[TNamed],
+                  *,
+                  lenient: bool = True) -> Optional[TNamed]:
     ...
 
 
 def resolve_snref(target_short_name: str,
                   items: Iterable[OdxNamed],
-                  expected_type: Any = None) -> Any:
+                  expected_type: Any = None,
+                  lenient: Optional[bool] = None) -> Any:
     candidates = [x for x in items if x.short_name == target_short_name]
 
     if not candidates:
-        odxraise(f"Cannot resolve short name reference to '{target_short_name}'")
+        if not lenient:
+            odxraise(f"Cannot resolve short name reference to '{target_short_name}'")
         return None
     elif len(candidates) > 1:
         odxraise(f"Cannot uniquely resolve short name reference to '{target_short_name}'")