odxtools 7.1.1__py3-none-any.whl → 7.3.0__py3-none-any.whl

odxtools/minmaxlengthtype.py

@@ -1,14 +1,17 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import Optional
+from typing import List, Optional
+from xml.etree import ElementTree
 
 from typing_extensions import override
 
 from .decodestate import DecodeState
 from .diagcodedtype import DctType, DiagCodedType
 from .encodestate import EncodeState
-from .exceptions import DecodeError, EncodeError, odxassert, odxraise
+from .exceptions import DecodeError, EncodeError, odxassert, odxraise, odxrequire
+from .odxlink import OdxDocFragment
 from .odxtypes import AtomicOdxType, DataType
+from .utils import dataclass_fields_asdict
 
 
 @dataclass
@@ -17,6 +20,21 @@ class MinMaxLengthType(DiagCodedType):
     max_length: Optional[int]
     termination: str
 
+    @staticmethod
+    @override
+    def from_et(et_element: ElementTree.Element,
+                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")))
+        termination = odxrequire(et_element.get("TERMINATION"))
+
+        return MinMaxLengthType(
+            min_length=min_length, max_length=max_length, termination=termination, **kwargs)
+
     def __post_init__(self) -> None:
         odxassert(self.max_length is None or self.min_length <= self.max_length)
         odxassert(

odxtools/modification.py

@@ -1,12 +1,10 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Dict, List, Optional
+from typing import Any, Dict, List, Optional
 from xml.etree import ElementTree
 
 from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
-
-if TYPE_CHECKING:
-    from .diaglayer import DiagLayer
+from .snrefcontext import SnRefContext
 
 
 @dataclass
@@ -27,5 +25,5 @@ class Modification:
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
         pass
 
-    def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
         pass

odxtools/multiplexer.py

@@ -1,6 +1,6 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Dict, List, Optional, Tuple
+from typing import Any, Dict, List, Optional, Tuple, Union, cast
 from xml.etree import ElementTree
 
 from typing_extensions import override
@@ -8,17 +8,15 @@ from typing_extensions import override
 from .complexdop import ComplexDop
 from .decodestate import DecodeState
 from .encodestate import EncodeState
-from .exceptions import DecodeError, EncodeError, odxraise, odxrequire
+from .exceptions import DecodeError, EncodeError, odxassert, odxraise, odxrequire
 from .multiplexercase import MultiplexerCase
 from .multiplexerdefaultcase import MultiplexerDefaultCase
 from .multiplexerswitchkey import MultiplexerSwitchKey
 from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
 from .odxtypes import AtomicOdxType, ParameterValue, odxstr_to_bool
+from .snrefcontext import SnRefContext
 from .utils import dataclass_fields_asdict
 
-if TYPE_CHECKING:
-    from .diaglayer import DiagLayer
-
 
 @dataclass
 class Multiplexer(ComplexDop):
@@ -81,92 +79,123 @@ class Multiplexer(ComplexDop):
     def encode_into_pdu(self, physical_value: ParameterValue, encode_state: EncodeState) -> None:
 
         if encode_state.cursor_bit_position != 0:
-            raise EncodeError(f"Multiplexer must be aligned, i.e. bit_position=0, but "
+            raise EncodeError(f"Multiplexer parameters must be aligned, i.e. bit_position=0, but "
                               f"{self.short_name} was passed the bit position "
                               f"{encode_state.cursor_bit_position}")
 
-        if not isinstance(physical_value, dict) or len(physical_value) != 1:
-            raise EncodeError("""Multiplexer should be defined as a dict
-            with only one key equal to the desired case""")
-
         orig_origin = encode_state.origin_byte_position
-        orig_cursor = encode_state.cursor_byte_position
-
         encode_state.origin_byte_position = encode_state.cursor_byte_position
 
-        case_name, case_value = next(iter(physical_value.items()))
-
-        for mux_case in self.cases or []:
-            if mux_case.short_name == case_name:
-                key_value, _ = self._get_case_limits(mux_case)
-
-                if self.switch_key.byte_position is not None:
-                    encode_state.cursor_byte_position = encode_state.origin_byte_position + self.switch_key.byte_position
-                encode_state.cursor_bit_position = self.switch_key.bit_position or 0
-
-                self.switch_key.dop.encode_into_pdu(
-                    physical_value=key_value, encode_state=encode_state)
-
-                if self.byte_position is not None:
-                    encode_state.cursor_byte_position = encode_state.origin_byte_position + self.byte_position
-                encode_state.cursor_bit_position = 0
-
-                if mux_case._structure is None:
-                    odxraise(f"Multiplexer case '{mux_case.short_name}' does not "
-                             f"reference a structure.")
-                    return
-
-                mux_case.structure.encode_into_pdu(
-                    physical_value=key_value, encode_state=encode_state)
-
-                encode_state.origin_byte_position = orig_origin
-                encode_state.cursor_byte_position = max(orig_cursor,
-                                                        encode_state.cursor_byte_position)
-                return
-
-        raise EncodeError(f"The case {case_name} is not found in Multiplexer {self.short_name}")
+        if isinstance(physical_value, (list, tuple)) and len(physical_value) == 2:
+            case_spec, case_value = physical_value
+        elif isinstance(physical_value, dict) and len(physical_value) == 1:
+            case_spec, case_value = next(iter(physical_value.items()))
+        else:
+            raise EncodeError(
+                f"Values of multiplexer parameters must be defined as a "
+                f"(case_name, content_value) tuple instead of as '{physical_value!r}'")
+
+        mux_case: Union[MultiplexerCase, MultiplexerDefaultCase]
+        if isinstance(case_spec, str):
+            applicable_cases = [x for x in self.cases if x.short_name == case_spec]
+            if len(applicable_cases) == 0:
+                raise EncodeError(
+                    f"Multiplexer {self.short_name} does not know any case called {case_spec}")
+
+            odxassert(len(applicable_cases) == 1)
+            mux_case = applicable_cases[0]
+            key_value, _ = self._get_case_limits(mux_case)
+        elif isinstance(case_spec, int):
+            applicable_cases = []
+            for x in self.cases:
+                lower, upper = cast(Tuple[int, int], self._get_case_limits(x))
+                if lower <= case_spec and case_spec <= upper:
+                    applicable_cases.append(x)
+
+            if len(applicable_cases) == 0:
+                if self.default_case is None:
+                    raise EncodeError(
+                        f"Multiplexer {self.short_name} does not know any case called {case_spec}")
+                mux_case = self.default_case
+                key_value = case_spec
+            else:
+                mux_case = applicable_cases[0]
+                key_value = case_spec
+        elif isinstance(case_spec, MultiplexerCase):
+            mux_case = case_spec
+            key_value, _ = self._get_case_limits(mux_case)
+        elif case_spec is None:
+            if self.default_case is None:
+                raise EncodeError(f"Multiplexer {self.short_name} does not define a default case")
+            key_value = 0
+        else:
+            raise EncodeError(f"Illegal case specification '{case_spec}' for "
+                              f"multiplexer {self.short_name}")
+
+        # the byte position of the switch key is relative to
+        # the multiplexer's position
+        encode_state.cursor_byte_position = encode_state.origin_byte_position + self.switch_key.byte_position
+        encode_state.cursor_bit_position = self.switch_key.bit_position or 0
+        self.switch_key.dop.encode_into_pdu(physical_value=key_value, encode_state=encode_state)
+        encode_state.cursor_bit_position = 0
+
+        if mux_case.structure is not None:
+            # the byte position of the content is specified by the
+            # BYTE-POSITION attribute of the multiplexer
+            encode_state.cursor_byte_position = encode_state.origin_byte_position + self.byte_position
+            mux_case.structure.encode_into_pdu(physical_value=case_value, encode_state=encode_state)
+
+        encode_state.origin_byte_position = orig_origin
 
     @override
     def decode_from_pdu(self, decode_state: DecodeState) -> ParameterValue:
-
-        # multiplexers are structures and thus the origin position
-        # must be moved to the start of the multiplexer
         orig_origin = decode_state.origin_byte_position
-        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
         decode_state.origin_byte_position = decode_state.cursor_byte_position
 
+        # Decode the switch key. Its BYTE-POSITION is relative to the
+        # that of the multiplexer.
+        if self.switch_key.byte_position is not None:
+            decode_state.cursor_byte_position = decode_state.origin_byte_position + self.switch_key.byte_position
+        decode_state.cursor_bit_position = self.switch_key.bit_position or 0
         key_value = self.switch_key.dop.decode_from_pdu(decode_state)
+        decode_state.cursor_bit_position = 0
 
         if not isinstance(key_value, int):
             odxraise(f"Multiplexer keys must be integers (is '{type(key_value).__name__}'"
                      f" for multiplexer '{self.short_name}')")
 
-        case_value: Optional[ParameterValue] = None
-        mux_case = None
-        for mux_case in self.cases or []:
+        # "If a matching CASE is found, the referenced STRUCTURE is
+        # analyzed at the BYTE-POSITION (child element of MUX)
+        # relatively to the byte position of the MUX."
+        decode_state.cursor_byte_position = decode_state.origin_byte_position + self.byte_position
+
+        applicable_case: Optional[Union[MultiplexerCase, MultiplexerDefaultCase]] = None
+        for mux_case in self.cases:
             lower, upper = self._get_case_limits(mux_case)
             if lower <= key_value and key_value <= upper:  # type: ignore[operator]
-                if mux_case._structure:
-                    case_value = mux_case._structure.decode_from_pdu(decode_state)
+                applicable_case = mux_case
                 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 applicable_case is None:
+            applicable_case = self.default_case
+
+        if applicable_case is None:
+            odxraise(
+                f"Cannot find an applicable case for value {key_value} in "
+                f"multiplexer {self.short_name}", DecodeError)
+            decode_state.origin_byte_position = orig_origin
+            return (None, 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)
+        if applicable_case.structure is not None:
+            case_value = applicable_case.structure.decode_from_pdu(decode_state)
+        else:
+            case_value = {}
 
-        mux_value = (mux_case.short_name, case_value)
+        result = (applicable_case.short_name, case_value)
 
-        # go back to the original origin
         decode_state.origin_byte_position = orig_origin
-        decode_state.cursor_byte_position = max(orig_cursor, decode_state.cursor_byte_position)
 
-        return mux_value
+        return result
 
     @override
     def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
@@ -191,12 +220,12 @@ class Multiplexer(ComplexDop):
                 odxlinks, key_physical_type=self.switch_key.dop.physical_type.base_data_type)
 
     @override
-    def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
-        super()._resolve_snrefs(diag_layer)
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
+        super()._resolve_snrefs(context)
 
-        self.switch_key._resolve_snrefs(diag_layer)
+        self.switch_key._resolve_snrefs(context)
         if self.default_case is not None:
-            self.default_case._resolve_snrefs(diag_layer)
+            self.default_case._resolve_snrefs(context)
 
         for mux_case in self.cases:
-            mux_case._resolve_snrefs(diag_layer)
+            mux_case._resolve_snrefs(context)

odxtools/multiplexercase.py

@@ -1,19 +1,17 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Dict, List, Optional
+from typing import 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, resolve_snref
 from .odxtypes import AtomicOdxType, DataType
+from .snrefcontext import SnRefContext
+from .structure import Structure
 from .utils import dataclass_fields_asdict
 
-if TYPE_CHECKING:
-    from .diaglayer import DiagLayer
-
 
 @dataclass
 class MultiplexerCase(NamedElement):
@@ -25,7 +23,7 @@ class MultiplexerCase(NamedElement):
     upper_limit: Limit
 
     def __post_init__(self) -> None:
-        self._structure: BasicStructure
+        self._structure: Optional[Structure]
 
     @staticmethod
     def from_et(et_element: ElementTree.Element,
@@ -64,21 +62,22 @@ class MultiplexerCase(NamedElement):
 
     def _mux_case_resolve_odxlinks(self, odxlinks: OdxLinkDatabase, *,
                                    key_physical_type: DataType) -> None:
+        self._structure = None
         if self.structure_ref:
-            self._structure = odxlinks.resolve(self.structure_ref)
+            self._structure = odxlinks.resolve(self.structure_ref, Structure)
 
         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:
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
         if self.structure_snref:
-            ddds = diag_layer.diag_data_dictionary_spec
-            self._structure = resolve_snref(self.structure_snref, ddds.structures, BasicStructure)
+            ddds = odxrequire(context.diag_layer).diag_data_dictionary_spec
+            self._structure = resolve_snref(self.structure_snref, ddds.structures, Structure)
 
     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:
+    def structure(self) -> Optional[Structure]:
         return self._structure

odxtools/multiplexerdefaultcase.py

@@ -1,17 +1,15 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Dict, List, Optional
+from typing import Any, Dict, List, Optional
 from xml.etree import ElementTree
 
-from .basicstructure import BasicStructure
 from .element import NamedElement
 from .exceptions import odxrequire
 from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef, resolve_snref
+from .snrefcontext import SnRefContext
+from .structure import Structure
 from .utils import dataclass_fields_asdict
 
-if TYPE_CHECKING:
-    from .diaglayer import DiagLayer
-
 
 @dataclass
 class MultiplexerDefaultCase(NamedElement):
@@ -20,12 +18,12 @@ class MultiplexerDefaultCase(NamedElement):
     structure_snref: Optional[str]
 
     def __post_init__(self) -> None:
-        self._structure: BasicStructure
+        self._structure: Optional[Structure]
 
     @staticmethod
     def from_et(et_element: ElementTree.Element,
                 doc_frags: List[OdxDocFragment]) -> "MultiplexerDefaultCase":
-        """Reads a Default Case for a Multiplexer."""
+        """Reads a default 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)
@@ -40,14 +38,15 @@ class MultiplexerDefaultCase(NamedElement):
         return {}
 
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
+        self._structure = None
         if self.structure_ref is not None:
-            self._structure = odxlinks.resolve(self.structure_ref)
+            self._structure = odxlinks.resolve(self.structure_ref, Structure)
 
-    def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
         if self.structure_snref:
-            ddds = diag_layer.diag_data_dictionary_spec
-            self._structure = resolve_snref(self.structure_snref, ddds.structures, BasicStructure)
+            ddds = odxrequire(context.diag_layer).diag_data_dictionary_spec
+            self._structure = resolve_snref(self.structure_snref, ddds.structures, Structure)
 
     @property
-    def structure(self) -> BasicStructure:
+    def structure(self) -> Optional[Structure]:
         return self._structure

odxtools/multiplexerswitchkey.py

@@ -1,13 +1,12 @@
+# SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Dict, List, Optional
+from typing import Any, Dict, List, Optional
 from xml.etree import ElementTree
 
 from .dataobjectproperty import DataObjectProperty
 from .exceptions import odxrequire
 from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef
-
-if TYPE_CHECKING:
-    from .diaglayer import DiagLayer
+from .snrefcontext import SnRefContext
 
 
 @dataclass
@@ -39,7 +38,7 @@ class MultiplexerSwitchKey:
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
         self._dop = odxlinks.resolve(self.dop_ref, DataObjectProperty)
 
-    def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
         pass
 
     @property

odxtools/negoutputparam.py

@@ -1,17 +1,15 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Dict, List, Optional
+from typing import Any, Dict, List, Optional
 from xml.etree import ElementTree
 
 from .dopbase import DopBase
 from .element import NamedElement
 from .exceptions import odxrequire
 from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef
+from .snrefcontext import SnRefContext
 from .utils import dataclass_fields_asdict
 
-if TYPE_CHECKING:
-    from .diaglayer import DiagLayer
-
 
 @dataclass
 class NegOutputParam(NamedElement):
@@ -35,7 +33,7 @@ class NegOutputParam(NamedElement):
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
         self._dop = odxlinks.resolve(self.dop_base_ref)
 
-    def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
         pass
 
     @property

odxtools/odxlink.py

@@ -26,7 +26,6 @@ class OdxDocFragment:
         return self.doc_name == other.doc_name
 
     def __hash__(self) -> int:
-        # only the document name is relevant for the hash value
         return hash(self.doc_name) + hash(self.doc_type)
 
 
@@ -59,10 +58,12 @@ class OdxLinkId:
         if not isinstance(other, OdxLinkId):
             return False
 
-        # we do take the document fragment into consideration here, because
-        # document fragments are handled using separate sub-databases,
-        # i.e. the same OdxId object can be put into all of them.
-        return self.local_id == other.local_id
+        # if the local ID is different, the whole id is different
+        if self.local_id != other.local_id:
+            return False
+
+        # the document fragments must be identical for the IDs to be identical
+        return self.doc_fragments == other.doc_fragments
 
     def __str__(self) -> str:
         return f"OdxLinkId('{self.local_id}')"
@@ -147,19 +148,6 @@ class OdxLinkRef:
     def __str__(self) -> str:
         return f"OdxLinkRef('{self.ref_id}')"
 
-    def __contains__(self, odx_id: OdxLinkId) -> bool:
-        """
-        Returns true iff a given OdxLinkId object is referenced.
-        """
-
-        # we must reference at to at least of the ID's document
-        # fragments
-        if not any(ref_doc in odx_id.doc_fragments for ref_doc in self.ref_docs):
-            return False
-
-        # the local ID of the reference and the object ID must match
-        return odx_id.local_id == self.ref_id
-
 
 T = TypeVar("T")
 
@@ -172,7 +160,7 @@ class OdxLinkDatabase:
     """
 
     def __init__(self) -> None:
-        self._db: Dict[OdxDocFragment, Dict[OdxLinkId, Any]] = {}
+        self._db: Dict[OdxDocFragment, Dict[str, Any]] = {}
 
     @overload
     def resolve(self, ref: OdxLinkRef, expected_type: None = None) -> Any:
@@ -189,7 +177,6 @@ class OdxLinkDatabase:
         If the database does not contain any object which is referred to, a
         KeyError exception is raised.
         """
-        odx_id = OdxLinkId(ref.ref_id, ref.ref_docs)
         for ref_frag in reversed(ref.ref_docs):
             doc_frag_db = self._db.get(ref_frag)
             if doc_frag_db is None:
@@ -204,8 +191,9 @@ class OdxLinkDatabase:
                 )
                 continue
 
-            obj = doc_frag_db.get(odx_id)
-            if obj is not None:
+            # locate an object exhibiting with the referenced local ID
+            # in the ID database for the document fragment
+            if (obj := doc_frag_db.get(ref.ref_id)) is not None:
                 if expected_type is not None:
                     odxassert(isinstance(obj, expected_type))
 
@@ -234,7 +222,6 @@ class OdxLinkDatabase:
         is returned.
         """
 
-        odx_id = OdxLinkId(ref.ref_id, ref.ref_docs)
         for ref_frag in reversed(ref.ref_docs):
             doc_frag_db = self._db.get(ref_frag)
             if doc_frag_db is None:
@@ -249,8 +236,7 @@ class OdxLinkDatabase:
                 )
                 continue
 
-            obj = doc_frag_db.get(odx_id)
-            if obj is not None:
+            if (obj := doc_frag_db.get(ref.ref_id)) is not None:
                 if expected_type is not None:
                     odxassert(isinstance(obj, expected_type))
 
@@ -272,7 +258,7 @@ class OdxLinkDatabase:
                 if doc_frag not in self._db:
                     self._db[doc_frag] = {}
 
-                self._db[doc_frag][odx_id] = obj
+                self._db[doc_frag][odx_id.local_id] = obj
 
 
 @overload

odxtools/odxtypes.py

@@ -235,7 +235,7 @@ class DataType(Enum):
         expected_type = self.python_type
         if isinstance(value, expected_type):
             return True
-        elif expected_type == float and isinstance(value, (int, float)):
+        elif expected_type is float and isinstance(value, (int, float)):
             return True
         elif self == DataType.A_BYTEFIELD and isinstance(value, (bytearray, bytes)):
             return True

odxtools/outputparam.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 Any, Dict, List, Optional
 from xml.etree import ElementTree
 
 from deprecation import deprecated
@@ -9,11 +9,9 @@ from .dopbase import DopBase
 from .element import IdentifiableElement
 from .exceptions import odxrequire
 from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef
+from .snrefcontext import SnRefContext
 from .utils import dataclass_fields_asdict
 
-if TYPE_CHECKING:
-    from .diaglayer import DiagLayer
-
 
 @dataclass
 class OutputParam(IdentifiableElement):
@@ -37,7 +35,7 @@ class OutputParam(IdentifiableElement):
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
         self._dop_base = odxlinks.resolve(self.dop_base_ref, DopBase)
 
-    def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
         pass
 
     @property

odxtools/parameterinfo.py

@@ -108,8 +108,8 @@ def parameter_info(param_list: Iterable[Parameter], quoted_names: bool = False)
             of.write(f"multiplexer; choices:\n")
             for mux_case in dop.cases:
                 of.write(f"  ({repr(mux_case.short_name)}, {{\n")
-                of.write(
-                    textwrap.indent(parameter_info(mux_case.structure.parameters, True), "    "))
+                if (struc := mux_case.structure) is not None:
+                    of.write(textwrap.indent(parameter_info(struc.parameters, True), "    "))
                 of.write(f"   }})\n")
             continue
 
@@ -128,7 +128,7 @@ def parameter_info(param_list: Iterable[Parameter], quoted_names: bool = False)
 
         if isinstance(cm, TexttableCompuMethod):
             of.write(f": enum; choices:\n")
-            for scale in cm.internal_to_phys:
+            for scale in odxrequire(cm.compu_internal_to_phys).compu_scales:
                 val_str = ""
                 if scale.lower_limit is not None:
                     val_str = f"({repr(scale.lower_limit.value)})"
@@ -166,8 +166,8 @@ def parameter_info(param_list: Iterable[Parameter], quoted_names: bool = False)
             else:
                 of.write(f": <unknown type>")
 
-            ll = cm.physical_lower_limit
-            ul = cm.physical_upper_limit
+            ll = cm.segment.physical_lower_limit
+            ul = cm.segment.physical_upper_limit
             if ll is None or ll.interval_type == IntervalType.INFINITE:
                 ll_str = "(-inf"
             else: