odxtools 5.2.6__py3-none-any.whl → 5.3.1__py3-none-any.whl

odxtools/endofpdufield.py

@@ -1,62 +1,28 @@
 # SPDX-License-Identifier: MIT
 from copy import copy
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, List, Optional
+from typing import List, Optional
 from xml.etree import ElementTree
 
-from .basicstructure import BasicStructure
-from .createsdgs import create_sdgs_from_et
 from .decodestate import DecodeState
-from .dopbase import DopBase
-from .element import IdentifiableElement
 from .encodestate import EncodeState
 from .exceptions import odxassert
-from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkRef
-from .odxtypes import ParameterValueDict, odxstr_to_bool
+from .field import Field
+from .odxlink import OdxDocFragment
+from .odxtypes import ParameterValueDict
 from .utils import dataclass_fields_asdict
 
-if TYPE_CHECKING:
-    from .diaglayer import DiagLayer
-
 
 @dataclass
-class EndOfPduField(DopBase):
+class EndOfPduField(Field):
     """End of PDU fields are structures that are repeated until the end of the PDU"""
-
-    structure_ref: Optional[OdxLinkRef]
-    structure_snref: Optional[str]
-    env_data_desc_ref: Optional[OdxLinkRef]
-    env_data_desc_snref: Optional[str]
     min_number_of_items: Optional[int]
     max_number_of_items: Optional[int]
 
-    def __post_init__(self) -> 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
-
-        odxassert(
-            num_struct_refs + num_edd_refs == 1,
-            "END-OF-PDU-FIELDs need to specify exactly one reference to a "
-            "structure or an environment data description")
-
     @staticmethod
     def from_et(et_element: ElementTree.Element,
                 doc_frags: List[OdxDocFragment]) -> "EndOfPduField":
-        kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, doc_frags))
-        sdgs = create_sdgs_from_et(et_element.find("SDGS"), doc_frags)
-
-        structure_ref = OdxLinkRef.from_et(et_element.find("BASIC-STRUCTURE-REF"), doc_frags)
-        structure_snref = None
-        if (edsnr_elem := et_element.find("BASIC-STRUCTURE-SNREF")) is not None:
-            structure_snref = edsnr_elem.get("SHORT-NAME")
-
-        env_data_desc_ref = OdxLinkRef.from_et(et_element.find("ENV-DATA-DESC-REF"), doc_frags)
-        env_data_desc_snref = None
-        if (edsnr_elem := et_element.find("ENV-DATA-DESC-SNREF")) is not None:
-            env_data_desc_snref = edsnr_elem.get("SHORT-NAME")
+        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)
@@ -67,32 +33,13 @@ class EndOfPduField(DopBase):
         else:
             max_number_of_items = None
 
-        is_visible_raw = odxstr_to_bool(et_element.get("IS-VISIBLE"))
         eopf = EndOfPduField(
-            sdgs=sdgs,
-            structure_ref=structure_ref,
-            structure_snref=structure_snref,
-            env_data_desc_ref=env_data_desc_ref,
-            env_data_desc_snref=env_data_desc_snref,
             min_number_of_items=min_number_of_items,
             max_number_of_items=max_number_of_items,
-            is_visible_raw=is_visible_raw,
             **kwargs)
 
         return eopf
 
-    @property
-    def structure(self) -> "BasicStructure":
-        """may be a Structure or a env-data-desc"""
-        return self._structure
-
-    @property
-    def bit_length(self):
-        return self.structure.bit_length
-
-    def convert_physical_to_internal(self, physical_value):
-        return self.structure.convert_physical_to_internal(physical_value)
-
     def convert_physical_to_bytes(
         self,
         physical_value: ParameterValueDict,
@@ -133,21 +80,3 @@ class EndOfPduField(DopBase):
             value.append(new_value)
 
         return value, next_byte_position
-
-    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
-        """Recursively resolve any odxlinks references"""
-        if self.structure_ref is not None:
-            self._structure = odxlinks.resolve(self.structure_ref)
-
-        if self.env_data_desc_ref is not None:
-            self._env_data_desc = odxlinks.resolve(self.env_data_desc_ref)
-
-    def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
-        """Recursively resolve any short-name references"""
-        if self.structure_snref is not None:
-            structures = diag_layer.diag_data_dictionary_spec.structures
-            self._structure = structures[self.structure_snref]
-
-        if self.env_data_desc_snref is not None:
-            env_data_descs = diag_layer.diag_data_dictionary_spec.env_data_descs
-            self._env_data_desc = env_data_descs[self.env_data_desc_snref]

odxtools/field.py

@@ -0,0 +1,94 @@
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, List, Optional
+from xml.etree import ElementTree
+
+from .environmentdatadescription import EnvironmentDataDescription
+from .basicstructure import BasicStructure
+from .createsdgs import create_sdgs_from_et
+from .dopbase import DopBase
+from .element import IdentifiableElement
+from .exceptions import odxassert, odxrequire
+from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkRef
+from .odxtypes import odxstr_to_bool
+from .utils import dataclass_fields_asdict
+
+if TYPE_CHECKING:
+    from .diaglayer import DiagLayer
+
+
+@dataclass
+class Field(DopBase):
+    structure_ref: Optional[OdxLinkRef]
+    structure_snref: Optional[str]
+    env_data_desc_ref: Optional[OdxLinkRef]
+    env_data_desc_snref: Optional[str]
+
+    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
+
+        odxassert(
+            num_struct_refs + num_edd_refs == 1,
+            "FIELDs need to specify exactly one reference to a "
+            "structure or an environment data description")
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "Field":
+        kwargs = dataclass_fields_asdict(DopBase.from_et(et_element, doc_frags))
+        sdgs = create_sdgs_from_et(et_element.find("SDGS"), doc_frags)
+
+        structure_ref = OdxLinkRef.from_et(et_element.find("BASIC-STRUCTURE-REF"), doc_frags)
+        structure_snref = None
+        if (edsnr_elem := et_element.find("BASIC-STRUCTURE-SNREF")) is not None:
+            structure_snref = edsnr_elem.get("SHORT-NAME")
+
+        env_data_desc_ref = OdxLinkRef.from_et(et_element.find("ENV-DATA-DESC-REF"), doc_frags)
+        env_data_desc_snref = None
+        if (edsnr_elem := et_element.find("ENV-DATA-DESC-SNREF")) is not None:
+            env_data_desc_snref = edsnr_elem.get("SHORT-NAME")
+
+        is_visible_raw = odxstr_to_bool(et_element.get("IS-VISIBLE"))
+        return Field(
+            sdgs=sdgs,
+            structure_ref=structure_ref,
+            structure_snref=structure_snref,
+            env_data_desc_ref=env_data_desc_ref,
+            env_data_desc_snref=env_data_desc_snref,
+            is_visible_raw=is_visible_raw,
+            **kwargs)
+
+    @property
+    def structure(self) -> BasicStructure:
+        """may be a Structure or a env-data-desc"""
+        return odxrequire(self._structure, "EnvironmentDataDescription is not supported")
+
+    @property
+    def bit_length(self):
+        return self.structure.bit_length
+
+    def convert_physical_to_internal(self, physical_value):
+        return self.structure.convert_physical_to_internal(physical_value)
+
+    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
+        """Recursively resolve any odxlinks references"""
+        if self.structure_ref is not None:
+            self._structure = odxlinks.resolve(self.structure_ref, BasicStructure)
+
+        if self.env_data_desc_ref is not None:
+            self._env_data_desc = odxlinks.resolve(self.env_data_desc_ref,
+                                                   EnvironmentDataDescription)
+
+    def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
+        """Recursively resolve any short-name references"""
+        if self.structure_snref is not None:
+            structures = diag_layer.diag_data_dictionary_spec.structures
+            self._structure = odxrequire(structures.get(self.structure_snref))
+
+        if self.env_data_desc_snref is not None:
+            env_data_descs = diag_layer.diag_data_dictionary_spec.env_data_descs
+            self._env_data_desc = odxrequire(env_data_descs.get(self.env_data_desc_snref))

odxtools/isotp_state_machine.py

@@ -5,6 +5,7 @@ import asyncio
 import re
 import sys
 from enum import IntEnum
+from typing import Iterable, List, Optional, Tuple, Union
 
 import bitstruct
 import can
@@ -28,7 +29,7 @@ class IsoTpStateMachine:
         "([a-zA-Z0-9_-]*) *([0-9A-Fa-f ]*) *\[[0-9]*\] *([ 0-9A-Fa-f]*)")
     can_log_frame_re = re.compile("\([0-9.]*\) *([a-zA-Z0-9_-]*) ([0-9A-Fa-f]*)#([0-9A-Fa-f]*)")
 
-    def __init__(self, can_rx_ids):
+    def __init__(self, can_rx_ids: Union[int, List[int]]):
         if isinstance(can_rx_ids, int):
             can_rx_ids = [can_rx_ids]
 
@@ -36,21 +37,21 @@ class IsoTpStateMachine:
         assert isinstance(self._can_rx_ids, list)
 
         self._telegram_specified_len = [0] * len(can_rx_ids)
-        self._telegram_data = [None] * len(can_rx_ids)
+        self._telegram_data: List[Optional[bytearray]] = [None] * len(can_rx_ids)
         self._telegram_last_rx_fragment_idx = [0] * len(can_rx_ids)
 
-    def decode_rx_frame(self, rx_id, data, do_yield=False):
+    def decode_rx_frame(self, rx_id: int, data: bytes) -> Iterable[Tuple[int, bytes]]:
         """Handle the ISO-TP state transitions caused by a CAN frame.
 
-        E.g., add some data to a telegram, etc.
+        E.g., add some data to a telegram, etc. Returns a generator of
+        (receive_id, payload_data) tuples.
         """
         try:
             telegram_idx = self._can_rx_ids.index(rx_id)
         except ValueError:
-            return False  # unknown CAN ID
+            return  # unknown CAN ID
 
         # decode the isotp segment
-        result = True
         (frame_type,) = bitstruct.unpack("u4", data)
         telegram_len = None
         if frame_type == IsoTp.FRAME_TYPE_SINGLE:
@@ -59,14 +60,13 @@ class IsoTpStateMachine:
             self.on_single_frame(telegram_idx, data[1:1 + telegram_len])
             self.on_telegram_complete(telegram_idx, data[1:1 + telegram_len])
 
-            if do_yield:
-                yield (rx_id, data[1:1 + telegram_len])
+            yield (rx_id, data[1:1 + telegram_len])
 
         elif frame_type == IsoTp.FRAME_TYPE_FIRST:
             frame_type, telegram_len = bitstruct.unpack("u4u12", data)
 
             self._telegram_specified_len[telegram_idx] = telegram_len
-            self._telegram_data[telegram_idx] = data[2:]
+            self._telegram_data[telegram_idx] = bytearray(data[2:])
             self._telegram_last_rx_fragment_idx[telegram_idx] = 0
 
             self.on_first_frame(telegram_idx, data)
@@ -75,38 +75,34 @@ class IsoTpStateMachine:
             frame_type, rx_segment_idx = bitstruct.unpack("u4u4", data)
 
             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)
 
             if expected_segment_idx == rx_segment_idx:
                 self._telegram_last_rx_fragment_idx[telegram_idx] = rx_segment_idx
-                self._telegram_data[telegram_idx] += data[1:]
+                telegram_data += data[1:]
 
                 n = self._telegram_specified_len[telegram_idx]
-                if len(self._telegram_data[telegram_idx]) > n:
+                if len(telegram_data) > n:
                     # can frames can include padding, i.e. the length
                     # of the telegram payload is not necessarily a
                     # multiple of the segment payloads
-                    self._telegram_data[telegram_idx] = self._telegram_data[telegram_idx][:n]
-            else:
-                result = False
+                    telegram_data = telegram_data[:n]
 
             self.on_consecutive_frame(telegram_idx, rx_segment_idx, data[1:])
 
             if expected_segment_idx != rx_segment_idx:
                 self.on_sequence_error(telegram_idx, expected_segment_idx, rx_segment_idx)
-            elif len(self._telegram_data[telegram_idx]) == n:
-                self.on_telegram_complete(telegram_idx, self._telegram_data[telegram_idx])
-                if do_yield:
-                    yield (rx_id, self._telegram_data[telegram_idx])
+            elif len(telegram_data) == n:
+                self.on_telegram_complete(telegram_idx, telegram_data)
+                yield (rx_id, telegram_data)
 
         elif frame_type == IsoTp.FRAME_TYPE_FLOW_CONTROL:
             frame_type, flow_control_flag = bitstruct.unpack("u4u4", data)
             self.on_flow_control_frame(telegram_idx, flow_control_flag)
         else:
-            result = False
             self.on_frame_type_error(telegram_idx, frame_type)
 
-        return result
-
     async def read_telegrams(self, bus):
         """This is equivalent to the :py:meth:`file.readlines()` method, but
         it yields ISO-TP telegrams instead of lines.
@@ -130,7 +126,7 @@ class IsoTpStateMachine:
                 await rx_event.wait()
 
                 msg = bus.recv()
-                for tmp in self.decode_rx_frame(msg.arbitration_id, msg.data, do_yield=True):
+                for tmp in self.decode_rx_frame(msg.arbitration_id, msg.data):
                     yield tmp
         else:
             # input is a file
@@ -148,7 +144,7 @@ class IsoTpStateMachine:
                     frame_data = bytearray(
                         map(lambda x: int(x, 16), frame_data_formatted.split(" ")))
 
-                    for tmp in self.decode_rx_frame(frame_id, frame_data, do_yield=True):
+                    for tmp in self.decode_rx_frame(frame_id, frame_data):
                         yield tmp
 
                 elif m := self.can_log_frame_re.match(cur_line.strip()):
@@ -162,7 +158,7 @@ class IsoTpStateMachine:
                     ]
                     frame_data = bytearray(map(lambda x: int(x, 16), frame_data_list))
 
-                    for tmp in self.decode_rx_frame(frame_id, frame_data, do_yield=True):
+                    for tmp in self.decode_rx_frame(frame_id, frame_data):
                         yield tmp
 
                 else:

odxtools/matchingparameter.py

@@ -23,7 +23,7 @@ class MatchingParameter:
     diag_comm_snref: str
     out_param_if: str
 
-    def __post_init__(self):
+    def __post_init__(self) -> None:
         odxassert(is_short_name(self.diag_comm_snref))
         odxassert(is_short_name_path(self.out_param_if))
 

odxtools/multiplexer.py

@@ -63,7 +63,7 @@ class Multiplexer(DopBase):
         return None
 
     def _get_case_limits(self, case: MultiplexerCase):
-        key_type = self.switch_key._dop.physical_type.base_data_type
+        key_type = self.switch_key.dop.physical_type.base_data_type
         lower_limit = key_type.make_from(case.lower_limit)
         upper_limit = key_type.make_from(case.upper_limit)
         return lower_limit, upper_limit
@@ -80,7 +80,6 @@ class Multiplexer(DopBase):
             with only one key equal to the desired case""")
 
         case_name, case_value = next(iter(physical_value.items()))
-        key_pos = self.switch_key.byte_position
         case_pos = self.byte_position
 
         for case in self.cases or []:
@@ -92,14 +91,11 @@ class Multiplexer(DopBase):
                     case_bytes = bytes()
 
                 key_value, _ = self._get_case_limits(case)
-                sk_bit_position = self.switch_key.bit_position
-                sk_bit_position = sk_bit_position if sk_bit_position is not None else 0
-                key_bytes = self.switch_key._dop.convert_physical_to_bytes(
-                    key_value, encode_state, sk_bit_position)
+                key_bytes = self.switch_key.convert_physical_to_bytes(key_value, encode_state)
 
-                mux_len = max(len(key_bytes) + key_pos, len(case_bytes) + case_pos)
+                mux_len = max(len(key_bytes), len(case_bytes) + case_pos)
                 mux_bytes = bytearray(mux_len)
-                mux_bytes[key_pos:key_pos + len(key_bytes)] = key_bytes
+                mux_bytes[:len(key_bytes)] = key_bytes
                 mux_bytes[case_pos:case_pos + len(case_bytes)] = case_bytes
 
                 return bytes(mux_bytes)
@@ -111,17 +107,9 @@ class Multiplexer(DopBase):
         if bit_position != 0:
             raise DecodeError("Multiplexer must be aligned, i.e. bit_position=0, but "
                               f"{self.short_name} was passed the bit position {bit_position}")
-        byte_code = decode_state.coded_message[decode_state.next_byte_position:]
-        key_decode_state = DecodeState(
-            coded_message=byte_code[self.switch_key.byte_position:],
-            parameter_values=dict(),
-            next_byte_position=0,
-        )
-        bit_position_int = (
-            self.switch_key.bit_position if self.switch_key.bit_position is not None else 0)
-        key_value, key_next_byte = self.switch_key._dop.convert_bytes_to_physical(
-            key_decode_state, bit_position=bit_position_int)
+        key_value, key_next_byte = self.switch_key.convert_bytes_to_physical(decode_state)
 
+        byte_code = decode_state.coded_message[decode_state.next_byte_position:]
         case_decode_state = DecodeState(
             coded_message=byte_code[self.byte_position:],
             parameter_values=dict(),

odxtools/multiplexercase.py

@@ -17,30 +17,46 @@ if TYPE_CHECKING:
 class MultiplexerCase(NamedElement):
     """This class represents a Case which represents multiple options in a Multiplexer."""
 
-    structure_ref: OdxLinkRef
+    structure_ref: Optional[OdxLinkRef]
+    structure_snref: Optional[str]
     lower_limit: str
     upper_limit: str
 
     def __post_init__(self) -> None:
-        self._structure: Optional[BasicStructure] = None
+        self._structure: BasicStructure
 
     @staticmethod
     def from_et(et_element: ElementTree.Element,
                 doc_frags: List[OdxDocFragment]) -> "MultiplexerCase":
         """Reads a Case for a Multiplexer."""
         kwargs = dataclass_fields_asdict(NamedElement.from_et(et_element, doc_frags))
-        structure_ref = odxrequire(OdxLinkRef.from_et(et_element.find("STRUCTURE-REF"), 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"))
 
         return MultiplexerCase(
-            structure_ref=structure_ref, lower_limit=lower_limit, upper_limit=upper_limit, **kwargs)
+            structure_ref=structure_ref,
+            structure_snref=structure_snref,
+            lower_limit=lower_limit,
+            upper_limit=upper_limit,
+            **kwargs)
 
     def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
         return {}
 
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
-        self._structure = odxlinks.resolve(self.structure_ref)
+        if self.structure_ref:
+            self._structure = odxlinks.resolve(self.structure_ref)
 
     def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
-        pass
+        if self.structure_snref:
+            ddds = diag_layer.diag_data_dictionary_spec
+            self._structure = odxrequire(ddds.structures.get(self.structure_snref))
+
+    @property
+    def structure(self) -> BasicStructure:
+        return self._structure

odxtools/multiplexerdefaultcase.py

@@ -5,6 +5,7 @@ from xml.etree import ElementTree
 
 from .basicstructure import BasicStructure
 from .element import NamedElement
+from .exceptions import odxrequire
 from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef
 from .utils import dataclass_fields_asdict
 
@@ -16,6 +17,7 @@ if TYPE_CHECKING:
 class MultiplexerDefaultCase(NamedElement):
     """This class represents a Default Case, which is selected when there are no cases defined in the Multiplexer."""
     structure_ref: Optional[OdxLinkRef]
+    structure_snref: Optional[str]
 
     def __post_init__(self) -> None:
         self._structure: Optional[BasicStructure] = None
@@ -27,8 +29,12 @@ class MultiplexerDefaultCase(NamedElement):
         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"))
 
-        return MultiplexerDefaultCase(structure_ref=structure_ref, **kwargs)
+        return MultiplexerDefaultCase(
+            structure_ref=structure_ref, structure_snref=structure_snref, **kwargs)
 
     def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
         return {}
@@ -38,4 +44,6 @@ class MultiplexerDefaultCase(NamedElement):
             self._structure = odxlinks.resolve(self.structure_ref)
 
     def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
-        pass
+        if self.structure_snref:
+            ddds = diag_layer.diag_data_dictionary_spec
+            self._structure = odxrequire(ddds.structures.get(self.structure_snref))

odxtools/multiplexerswitchkey.py

@@ -1,53 +1,18 @@
-# SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Dict, List, Optional
+from typing import List
 from xml.etree import ElementTree
 
-from .dataobjectproperty import DataObjectProperty
-from .exceptions import odxrequire
-from .globals import logger
-from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef
-
-if TYPE_CHECKING:
-    from .diaglayer import DiagLayer
+from .odxlink import OdxDocFragment
+from .positioneddataobjectproperty import PositionedDataObjectProperty
+from .utils import dataclass_fields_asdict
 
 
 @dataclass
-class MultiplexerSwitchKey:
-    """This class represents a Switch Key, which is used to select one of the cases defined in the Multiplexer."""
-
-    byte_position: int
-    bit_position: Optional[int]
-    dop_ref: OdxLinkRef
-
-    def __post_init__(self):
-        self._dop: DataObjectProperty = None  # type: ignore
+class MultiplexerSwitchKey(PositionedDataObjectProperty):
 
     @staticmethod
     def from_et(et_element: ElementTree.Element,
                 doc_frags: List[OdxDocFragment]) -> "MultiplexerSwitchKey":
-        """Reads a Switch Key for a Multiplexer."""
-        byte_position = int(odxrequire(et_element.findtext("BYTE-POSITION", "0")))
-        bit_position_str = et_element.findtext("BIT-POSITION")
-        bit_position = int(bit_position_str) if bit_position_str is not None else None
-        dop_ref = odxrequire(OdxLinkRef.from_et(et_element.find("DATA-OBJECT-PROP-REF"), doc_frags))
-
-        return MultiplexerSwitchKey(
-            byte_position=byte_position,
-            bit_position=bit_position,
-            dop_ref=dop_ref,
-        )
-
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
-        return {}
-
-    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
-        dop = odxlinks.resolve(self.dop_ref)
-        if isinstance(dop, DataObjectProperty):
-            self._dop = dop
-        else:
-            logger.warning(
-                f"DATA-OBJECT-PROP-REF '{self.dop_ref}' could not be resolved in SWITCH-KEY.")
-
-    def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
-        pass
+        kwargs = dataclass_fields_asdict(
+            PositionedDataObjectProperty.from_et(et_element, doc_frags))
+        return MultiplexerSwitchKey(**kwargs)

odxtools/odxlink.py

@@ -12,11 +12,15 @@ class OdxDocFragment:
     doc_name: str
     doc_type: Optional[str]
 
-    def __eq__(self, other) -> bool:
+    def __eq__(self, other: Any) -> bool:
         if other is None:
-            # if the other document fragment is not specified, we treat it as a wildcard...
+            # if the other document fragment is not specified, we
+            # treat it as a wildcard...
             return True
 
+        if not isinstance(other, OdxDocFragment):
+            return False
+
         # the ODX spec says that the doctype can be ignored...
         return self.doc_name == other.doc_name
 
@@ -59,7 +63,7 @@ class OdxLinkId:
         # i.e. the same OdxId object can be put into all of them.
         return self.local_id == other.local_id
 
-    def __str__(self):
+    def __str__(self) -> str:
         return f"OdxLinkId('{self.local_id}')"
 
     @staticmethod
@@ -139,7 +143,7 @@ class OdxLinkRef:
         """Construct an OdxLinkRef for a given OdxLinkId."""
         return OdxLinkRef(odxid.local_id, odxid.doc_fragments)
 
-    def __str__(self):
+    def __str__(self) -> str:
         return f"OdxLinkRef('{self.ref_id}')"
 
     def __contains__(self, odx_id: OdxLinkId) -> bool:

odxtools/odxtypes.py

@@ -6,7 +6,7 @@ from xml.etree import ElementTree
 from .exceptions import odxassert, odxraise, odxrequire
 
 if TYPE_CHECKING:
-    from odxtools.parameters.parameter import Parameter
+    from .parameters.parameter import Parameter
 
 
 def bytefield_to_bytearray(bytefield: str) -> bytearray:

odxtools/parameters/codedconstparameter.py

@@ -47,10 +47,12 @@ class CodedConstParameter(Parameter):
     def internal_data_type(self) -> DataType:
         return self.diag_coded_type.base_data_type
 
-    def is_required(self):
+    @property
+    def is_required(self) -> bool:
         return False
 
-    def is_optional(self):
+    @property
+    def is_settable(self) -> bool:
         return False
 
     def get_coded_value(self):

odxtools/parameters/dynamicparameter.py

@@ -11,11 +11,13 @@ class DynamicParameter(Parameter):
     def parameter_type(self) -> ParameterType:
         return "DYNAMIC"
 
-    def is_required(self):
-        raise NotImplementedError("DynamicParameter.is_required is not implemented yet.")
+    @property
+    def is_required(self) -> bool:
+        raise NotImplementedError(".is_required for a DynamicParameter")
 
-    def is_optional(self):
-        raise NotImplementedError("DynamicParameter.is_optional is not implemented yet.")
+    @property
+    def is_settable(self) -> bool:
+        raise NotImplementedError(".is_settable for a DynamicParameter")
 
     def get_coded_value(self):
         raise NotImplementedError("Encoding a DynamicParameter is not implemented yet.")