odxtools 10.2.1__py3-none-any.whl → 10.4.0__py3-none-any.whl

odxtools/isotp_state_machine.py

@@ -44,7 +44,7 @@ class IsoTpStateMachine:
         self._telegram_data: list[bytearray | None] = [None] * len(can_rx_ids)
         self._telegram_last_rx_fragment_idx = [0] * len(can_rx_ids)
 
-    def decode_rx_frame(self, rx_id: int, data: bytes) -> Iterable[tuple[int, bytes]]:
+    def decode_rx_frame(self, rx_id: int, data: bytes | bytearray) -> Iterable[tuple[int, bytes]]:
         """Handle the ISO-TP state transitions caused by a CAN frame.
 
         E.g., add some data to a telegram, etc. Returns a generator of
@@ -67,7 +67,7 @@ class IsoTpStateMachine:
             self.on_single_frame(telegram_idx, data[1:1 + telegram_len])
             self.on_telegram_complete(telegram_idx, data[1:1 + telegram_len])
 
-            yield (rx_id, data[1:1 + telegram_len])
+            yield (rx_id, bytes(data[1:1 + telegram_len]))
 
         elif frame_type == IsoTp.FRAME_TYPE_FIRST:
             frame_type, telegram_len = bitstruct.unpack("u4u12", data)
@@ -105,7 +105,7 @@ class IsoTpStateMachine:
                 self.on_sequence_error(telegram_idx, expected_segment_idx, rx_segment_idx)
             elif len(telegram_data) == n:
                 self.on_telegram_complete(telegram_idx, telegram_data)
-                yield (rx_id, telegram_data)
+                yield (rx_id, bytes(telegram_data))
 
         elif frame_type == IsoTp.FRAME_TYPE_FLOW_CONTROL:
             frame_type, flow_control_flag = bitstruct.unpack("u4u4", data)
@@ -185,7 +185,7 @@ class IsoTpStateMachine:
         """
         return self._can_rx_ids[telegram_idx]
 
-    def telegram_data(self, telegram_idx: int) -> bytes | None:
+    def telegram_data(self, telegram_idx: int) -> bytearray | None:
         """Given a Telegram index, returns the data received for this telegram
         so far.
 
@@ -196,16 +196,16 @@ class IsoTpStateMachine:
     ##############
     # Callbacks
     ##############
-    def on_single_frame(self, telegram_idx: int, frame_payload: bytes) -> None:
+    def on_single_frame(self, telegram_idx: int, frame_payload: bytes | bytearray) -> None:
         """Callback method for when an ISO-TP message of type "single frame" has been received"""
         pass
 
-    def on_first_frame(self, telegram_idx: int, frame_payload: bytes) -> None:
+    def on_first_frame(self, telegram_idx: int, frame_payload: bytes | bytearray) -> None:
         """Callback method for when an ISO-TP message of type "first frame" has been received"""
         pass
 
     def on_consecutive_frame(self, telegram_idx: int, segment_idx: int,
-                             frame_payload: bytes) -> None:
+                             frame_payload: bytes | bytearray) -> None:
         """Callback method for when an ISO-TP message of type "consecutive frame" has been received"""
         pass
 
@@ -221,7 +221,7 @@ class IsoTpStateMachine:
         """Method called when a frame exhibiting an unknown frame type has been received"""
         pass
 
-    def on_telegram_complete(self, telegram_idx: int, telegram_payload: bytes) -> None:
+    def on_telegram_complete(self, telegram_idx: int, telegram_payload: bytes | bytearray) -> None:
         """Method called when an ISO-TP telegram has been fully received"""
         pass
 
@@ -264,7 +264,7 @@ class IsoTpActiveDecoder(IsoTpStateMachine):
         """
         return self._can_tx_ids[telegram_idx]
 
-    def on_single_frame(self, telegram_idx: int, frame_payload: bytes) -> None:
+    def on_single_frame(self, telegram_idx: int, frame_payload: bytes | bytearray) -> None:
         # send ACK
         # rx_id = self.can_rx_id(telegram_idx)
         tx_id = self.can_tx_id(telegram_idx)
@@ -283,7 +283,7 @@ class IsoTpActiveDecoder(IsoTpStateMachine):
 
         super().on_first_frame(telegram_idx, frame_payload)
 
-    def on_first_frame(self, telegram_idx: int, frame_payload: bytes) -> None:
+    def on_first_frame(self, telegram_idx: int, frame_payload: bytes | bytearray) -> None:
         # send ACK
         # rx_id = self.can_rx_id(telegram_idx)
         tx_id = self.can_tx_id(telegram_idx)
@@ -306,7 +306,7 @@ class IsoTpActiveDecoder(IsoTpStateMachine):
         super().on_first_frame(telegram_idx, frame_payload)
 
     def on_consecutive_frame(self, telegram_idx: int, segment_idx: int,
-                             frame_payload: bytes) -> None:
+                             frame_payload: bytes | bytearray) -> None:
         num_received = self._frames_received[telegram_idx]
         if num_received is None:
             # consequtive frame received before a first frame.

odxtools/itemvalue.py

@@ -0,0 +1,77 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass, field
+from typing import Any
+from xml.etree import ElementTree
+
+from .audience import Audience
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkId
+from .snrefcontext import SnRefContext
+from .specialdatagroup import SpecialDataGroup
+from .text import Text
+
+
+@dataclass(kw_only=True)
+class ItemValue:
+    """This class represents a ITEM-VALUE."""
+
+    phys_constant_value: str | None
+    meaning: Text | None = None
+    key: str | None = None
+    rule: str | None = None
+    description: Text | None = None
+    sdgs: list[SpecialDataGroup] = field(default_factory=list)
+    audience: Audience | None = None
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "ItemValue":
+        phys_constant_value = et_element.findtext("PHYS-CONSTANT-VALUE")
+
+        meaning = None
+        if (meaning_elem := et_element.find("MEANING")) is not None:
+            meaning = Text.from_et(meaning_elem, context)
+
+        key = et_element.findtext("KEY")
+        rule = et_element.findtext("RULE")
+
+        description = None
+        if (description_elem := et_element.find("DESCRIPTION")) is not None:
+            description = Text.from_et(description_elem, context)
+
+        sdgs = [SpecialDataGroup.from_et(sdge, context) for sdge in et_element.iterfind("SDGS/SDG")]
+
+        audience = None
+        if (aud_elem := et_element.find("AUDIENCE")) is not None:
+            audience = Audience.from_et(aud_elem, context)
+
+        return ItemValue(
+            phys_constant_value=phys_constant_value,
+            meaning=meaning,
+            key=key,
+            rule=rule,
+            description=description,
+            sdgs=sdgs,
+            audience=audience,
+        )
+
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
+        result = {}
+
+        if self.audience is not None:
+            result.update(self.audience._build_odxlinks())
+        for sdg in self.sdgs:
+            result.update(sdg._build_odxlinks())
+
+        return result
+
+    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
+        if self.audience is not None:
+            self.audience._resolve_odxlinks(odxlinks)
+        for sdg in self.sdgs:
+            sdg._resolve_odxlinks(odxlinks)
+
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
+        if self.audience is not None:
+            self.audience._resolve_snrefs(context)
+        for sdg in self.sdgs:
+            sdg._resolve_snrefs(context)

odxtools/multipleecujob.py

@@ -0,0 +1,178 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass, field
+from typing import Any
+from xml.etree import ElementTree
+
+from .admindata import AdminData
+from .audience import Audience
+from .diaglayers.diaglayer import DiagLayer
+from .element import IdentifiableElement
+from .exceptions import odxrequire
+from .functionalclass import FunctionalClass
+from .inputparam import InputParam
+from .nameditemlist import NamedItemList
+from .negoutputparam import NegOutputParam
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkId, OdxLinkRef
+from .odxtypes import odxstr_to_bool
+from .outputparam import OutputParam
+from .progcode import ProgCode
+from .snrefcontext import SnRefContext
+from .specialdatagroup import SpecialDataGroup
+from .utils import dataclass_fields_asdict
+
+
+@dataclass(kw_only=True)
+class MultipleEcuJob(IdentifiableElement):
+    """A multiple ECU job is a diagnostic communication primitive.
+
+    A multiple ECU job is more complex than a diagnostic service and is
+    not provided natively by the ECU.  In particular, the job is
+    defined in external programs which are referenced by the attribute
+    `.prog_codes`.
+
+    In contrast to "single ECU jobs", a multiple ECU job only involves
+    calls to services provided by more than one ECU.
+
+    Multiple ECU jobs are defined in section 7.3.11 of the ASAM MCD-2
+    standard.
+    """
+
+    admin_data: AdminData | None = None
+    sdgs: list[SpecialDataGroup] = field(default_factory=list)
+    functional_class_refs: list[OdxLinkRef] = field(default_factory=list)
+    prog_codes: list[ProgCode] = field(default_factory=list)
+    input_params: NamedItemList[InputParam] = field(default_factory=NamedItemList)
+    output_params: NamedItemList[OutputParam] = field(default_factory=NamedItemList)
+    neg_output_params: NamedItemList[NegOutputParam] = field(default_factory=NamedItemList)
+    diag_layer_refs: list[OdxLinkRef] = field(default_factory=list)
+    audience: Audience | None = None
+    semantic: str | None = None
+    is_executable_raw: bool | None = None
+
+    @property
+    def functional_classes(self) -> NamedItemList[FunctionalClass]:
+        return self._functional_classes
+
+    @property
+    def diag_layers(self) -> NamedItemList[DiagLayer]:
+        return self._diag_layers
+
+    @property
+    def is_executable(self) -> bool:
+        return self.is_executable_raw in (True, None)
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "MultipleEcuJob":
+        kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, context))
+
+        admin_data = None
+        if (admin_data_elem := et_element.find("ADMIN-DATA")) is not None:
+            admin_data = AdminData.from_et(admin_data_elem, context)
+        sdgs = [SpecialDataGroup.from_et(sdge, context) for sdge in et_element.iterfind("SDGS/SDG")]
+        functional_class_refs = [
+            odxrequire(OdxLinkRef.from_et(el, context))
+            for el in et_element.iterfind("FUNCT-CLASS-REFS/FUNCT-CLASS-REF")
+        ]
+        prog_codes = [
+            ProgCode.from_et(pc_elem, context)
+            for pc_elem in et_element.iterfind("PROG-CODES/PROG-CODE")
+        ]
+
+        input_params = NamedItemList([
+            InputParam.from_et(el, context)
+            for el in et_element.iterfind("INPUT-PARAMS/INPUT-PARAM")
+        ])
+        output_params = NamedItemList([
+            OutputParam.from_et(el, context)
+            for el in et_element.iterfind("OUTPUT-PARAMS/OUTPUT-PARAM")
+        ])
+        neg_output_params = NamedItemList([
+            NegOutputParam.from_et(el, context)
+            for el in et_element.iterfind("NEG-OUTPUT-PARAMS/NEG-OUTPUT-PARAM")
+        ])
+        diag_layer_refs = [
+            odxrequire(OdxLinkRef.from_et(el, context))
+            for el in et_element.iterfind("DIAG-LAYER-REFS/DIAG-LAYER-REF")
+        ]
+        audience = None
+        if (aud_elem := et_element.find("AUDIENCE")) is not None:
+            audience = Audience.from_et(aud_elem, context)
+
+        semantic = et_element.attrib.get("SEMANTIC")
+        is_executable_raw = odxstr_to_bool(et_element.attrib.get("IS-EXECUTABLE"))
+
+        return MultipleEcuJob(
+            admin_data=admin_data,
+            sdgs=sdgs,
+            functional_class_refs=functional_class_refs,
+            prog_codes=prog_codes,
+            input_params=input_params,
+            output_params=output_params,
+            neg_output_params=neg_output_params,
+            diag_layer_refs=diag_layer_refs,
+            audience=audience,
+            semantic=semantic,
+            is_executable_raw=is_executable_raw,
+            **kwargs)
+
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
+        result = {self.odx_id: self}
+
+        if self.admin_data is not None:
+            result.update(self.admin_data._build_odxlinks())
+        for sdg in self.sdgs:
+            result.update(sdg._build_odxlinks())
+        for prog_code in self.prog_codes:
+            result.update(prog_code._build_odxlinks())
+        for input_param in self.input_params:
+            result.update(input_param._build_odxlinks())
+        for output_param in self.output_params:
+            result.update(output_param._build_odxlinks())
+        for neg_output_param in self.neg_output_params:
+            result.update(neg_output_param._build_odxlinks())
+        if self.audience is not None:
+            result.update(self.audience._build_odxlinks())
+
+        return result
+
+    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
+        if self.admin_data is not None:
+            self.admin_data._resolve_odxlinks(odxlinks)
+        for sdg in self.sdgs:
+            sdg._resolve_odxlinks(odxlinks)
+        for prog_code in self.prog_codes:
+            prog_code._resolve_odxlinks(odxlinks)
+        for input_param in self.input_params:
+            input_param._resolve_odxlinks(odxlinks)
+        for output_param in self.output_params:
+            output_param._resolve_odxlinks(odxlinks)
+        for neg_output_param in self.neg_output_params:
+            neg_output_param._resolve_odxlinks(odxlinks)
+        if self.audience is not None:
+            self.audience._resolve_odxlinks(odxlinks)
+
+        self._functional_classes = NamedItemList(
+            [odxlinks.resolve(fc_ref, FunctionalClass) for fc_ref in self.functional_class_refs])
+        self._diag_layers = NamedItemList(
+            [odxlinks.resolve(dl_ref, DiagLayer) for dl_ref in self.diag_layer_refs])
+
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
+        context.multiple_ecu_job = self
+
+        if self.admin_data is not None:
+            self.admin_data._resolve_snrefs(context)
+        for sdg in self.sdgs:
+            sdg._resolve_snrefs(context)
+        for prog_code in self.prog_codes:
+            prog_code._resolve_snrefs(context)
+        for input_param in self.input_params:
+            input_param._resolve_snrefs(context)
+        for output_param in self.output_params:
+            output_param._resolve_snrefs(context)
+        for neg_output_param in self.neg_output_params:
+            neg_output_param._resolve_snrefs(context)
+        if self.audience is not None:
+            self.audience._resolve_snrefs(context)
+
+        context.multiple_ecu_job = None

odxtools/multipleecujobspec.py

@@ -0,0 +1,142 @@
+# SPDX-License-Identifier: MIT
+from copy import copy
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, Any
+from xml.etree import ElementTree
+
+from .additionalaudience import AdditionalAudience
+from .diagdatadictionaryspec import DiagDataDictionarySpec
+from .diaglayers.ecushareddata import EcuSharedData
+from .functionalclass import FunctionalClass
+from .multipleecujob import MultipleEcuJob
+from .nameditemlist import NamedItemList
+from .odxcategory import OdxCategory
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkId, OdxLinkRef
+from .snrefcontext import SnRefContext
+from .utils import dataclass_fields_asdict
+
+if TYPE_CHECKING:
+    from .database import Database
+
+
+@dataclass(kw_only=True)
+class MultipleEcuJobSpec(OdxCategory):
+    multiple_ecu_jobs: NamedItemList[MultipleEcuJob] = field(default_factory=NamedItemList)
+    diag_data_dictionary_spec: DiagDataDictionarySpec | None = None
+    functional_classes: NamedItemList[FunctionalClass] = field(default_factory=NamedItemList)
+    additional_audiences: NamedItemList[AdditionalAudience] = field(default_factory=NamedItemList)
+    import_refs: list[OdxLinkRef] = field(default_factory=list)
+
+    @property
+    def imported_layers(self) -> NamedItemList[EcuSharedData]:
+        """The resolved IMPORT-REFs
+
+        ODXLINK defined by ECU-SHARED-DATA layers referenced via
+        IMPORT-REF ought to be treated as if they where defined
+        locally.
+        """
+        return self._imported_layers
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "MultipleEcuJobSpec":
+
+        base_obj = OdxCategory.from_et(et_element, context)
+        kwargs = dataclass_fields_asdict(base_obj)
+
+        multiple_ecu_jobs = NamedItemList([
+            MultipleEcuJob.from_et(el, context)
+            for el in et_element.iterfind("MULTIPLE-ECU-JOBS/MULTIPLE-ECU-JOB")
+        ])
+        diag_data_dictionary_spec = None
+        if (ddds_elem := et_element.find("DIAG-DATA-DICTIONARY-SPEC")) is not None:
+            diag_data_dictionary_spec = DiagDataDictionarySpec.from_et(ddds_elem, context)
+        functional_classes = NamedItemList([
+            FunctionalClass.from_et(el, context)
+            for el in et_element.iterfind("FUNCT-CLASSS/FUNCT-CLASS")
+        ])
+        additional_audiences = NamedItemList([
+            AdditionalAudience.from_et(el, context)
+            for el in et_element.iterfind("ADDITIONAL-AUDIENCES/ADDITIONAL-AUDIENCE")
+        ])
+        import_refs = [
+            OdxLinkRef.from_et(el, context) for el in et_element.iterfind("IMPORT-REFS/IMPORT-REF")
+        ]
+
+        return MultipleEcuJobSpec(
+            multiple_ecu_jobs=multiple_ecu_jobs,
+            diag_data_dictionary_spec=diag_data_dictionary_spec,
+            functional_classes=functional_classes,
+            additional_audiences=additional_audiences,
+            import_refs=import_refs,
+            **kwargs)
+
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
+        odxlinks = super()._build_odxlinks()
+
+        for multiple_ecu_job in self.multiple_ecu_jobs:
+            odxlinks.update(multiple_ecu_job._build_odxlinks())
+
+        if self.diag_data_dictionary_spec is not None:
+            odxlinks.update(self.diag_data_dictionary_spec._build_odxlinks())
+
+        for functional_class in self.functional_classes:
+            odxlinks.update(functional_class._build_odxlinks())
+
+        for additional_audience in self.additional_audiences:
+            odxlinks.update(additional_audience._build_odxlinks())
+
+        return odxlinks
+
+    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
+        # deal with the import refs: IDs defined therein are to be
+        # handled like they were local.
+        self._imported_layers: NamedItemList[EcuSharedData] = NamedItemList()
+        if self.import_refs:
+            extended_odxlinks = copy(odxlinks)
+            imported_links: dict[OdxLinkId, Any] = {}
+            for import_ref in self.import_refs:
+                imported_dl = odxlinks.resolve(import_ref, EcuSharedData)
+                self._imported_layers.append(imported_dl)
+
+                # replace the document fragments of the ODX id with
+                # the those of the muliple-ecu-spec. (be aware that
+                # the "original" locations are still available.)
+                imported_dl_links = imported_dl._build_odxlinks()
+                for link_id, obj in imported_dl_links.items():
+                    link_id = OdxLinkId(link_id.local_id, self.odx_id.doc_fragments)
+                    imported_links[link_id] = obj
+
+                extended_odxlinks.update(imported_links, overwrite=False)
+        else:
+            extended_odxlinks = odxlinks
+
+        for multiple_ecu_job in self.multiple_ecu_jobs:
+            multiple_ecu_job._resolve_odxlinks(extended_odxlinks)
+
+        if self.diag_data_dictionary_spec is not None:
+            self.diag_data_dictionary_spec._resolve_odxlinks(extended_odxlinks)
+
+        for functional_class in self.functional_classes:
+            functional_class._resolve_odxlinks(extended_odxlinks)
+
+        for additional_audiences in self.additional_audiences:
+            additional_audiences._resolve_odxlinks(extended_odxlinks)
+
+    def _finalize_init(self, database: "Database", odxlinks: OdxLinkDatabase) -> None:
+        super()._finalize_init(database, odxlinks)
+
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
+        super()._resolve_snrefs(context)
+
+        for multiple_ecu_job in self.multiple_ecu_jobs:
+            multiple_ecu_job._resolve_snrefs(context)
+
+        if self.diag_data_dictionary_spec is not None:
+            self.diag_data_dictionary_spec._resolve_snrefs(context)
+
+        for functional_class in self.functional_classes:
+            functional_class._resolve_snrefs(context)
+
+        for additional_audiences in self.additional_audiences:
+            additional_audiences._resolve_snrefs(context)

odxtools/nameditemlist.py

@@ -4,7 +4,7 @@ import typing
 from collections.abc import Collection, Iterable
 from copy import deepcopy
 from keyword import iskeyword
-from typing import Any, SupportsIndex, TypeVar, cast, overload, runtime_checkable
+from typing import Any, SupportsIndex, TypeVar, overload, runtime_checkable
 
 from .exceptions import odxraise
 
@@ -159,7 +159,7 @@ class ItemAttributeList(list[T]):
                 return super().__getitem__(key)
             return default
         else:
-            return cast(T | None, self._item_dict.get(key, default))
+            return self._item_dict.get(key, default)
 
     def __eq__(self, other: object) -> bool:
         """

odxtools/optionitem.py

@@ -0,0 +1,79 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass, field
+from typing import Any
+from xml.etree import ElementTree
+
+from .audience import Audience
+from .configitem import ConfigItem
+from .itemvalue import ItemValue
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkId
+from .snrefcontext import SnRefContext
+from .utils import dataclass_fields_asdict
+
+
+@dataclass(kw_only=True)
+class OptionItem(ConfigItem):
+    """This class represents a OPTION-ITEM."""
+
+    physical_default_value: str | None = None
+    item_values: list[ItemValue] = field(default_factory=list)
+    write_audience: Audience | None = None
+    read_audience: Audience | None = None
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "OptionItem":
+        kwargs = dataclass_fields_asdict(ConfigItem.from_et(et_element, context))
+
+        physical_default_value = et_element.findtext("PHYSICAL-DEFAULT-VALUE")
+
+        item_values = [
+            ItemValue.from_et(el, context) for el in et_element.iterfind("ITEM-VALUES/ITEM-VALUE")
+        ]
+
+        write_audience = None
+        if (wa_elem := et_element.find("WRITE-AUDIENCE")) is not None:
+            write_audience = Audience.from_et(wa_elem, context)
+
+        read_audience = None
+        if (ra_elem := et_element.find("READ-AUDIENCE")) is not None:
+            read_audience = Audience.from_et(ra_elem, context)
+
+        return OptionItem(
+            physical_default_value=physical_default_value,
+            item_values=item_values,
+            write_audience=write_audience,
+            read_audience=read_audience,
+            **kwargs)
+
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
+        result = super()._build_odxlinks()
+
+        for item_value in self.item_values:
+            result.update(item_value._build_odxlinks())
+        if self.write_audience is not None:
+            result.update(self.write_audience._build_odxlinks())
+        if self.read_audience is not None:
+            result.update(self.read_audience._build_odxlinks())
+
+        return result
+
+    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
+        super()._resolve_odxlinks(odxlinks)
+
+        for item_value in self.item_values:
+            item_value._resolve_odxlinks(odxlinks)
+        if self.write_audience is not None:
+            self.write_audience._resolve_odxlinks(odxlinks)
+        if self.read_audience is not None:
+            self.read_audience._resolve_odxlinks(odxlinks)
+
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
+        super()._resolve_snrefs(context)
+
+        for item_value in self.item_values:
+            item_value._resolve_snrefs(context)
+        if self.write_audience is not None:
+            self.write_audience._resolve_snrefs(context)
+        if self.read_audience is not None:
+            self.read_audience._resolve_snrefs(context)

odxtools/outputparam.py

@@ -38,7 +38,7 @@ class OutputParam(IdentifiableElement):
         return OutputParam(dop_base_ref=dop_base_ref, semantic=semantic, **kwargs)
 
     def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
-        return {}
+        return {self.odx_id: self}
 
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
         self._dop = odxlinks.resolve(self.dop_base_ref, DopBase)

odxtools/parameters/codedconstparameter.py

@@ -1,7 +1,7 @@
 # SPDX-License-Identifier: MIT
 import warnings
 from dataclasses import dataclass
-from typing import Any, cast
+from typing import Any
 from xml.etree import ElementTree
 
 from typing_extensions import override
@@ -57,8 +57,7 @@ class CodedConstParameter(Parameter):
             coded_value_raw=coded_value_raw, diag_coded_type=diag_coded_type, **kwargs)
 
     def __post_init__(self) -> None:
-        self._coded_value = cast(
-            AtomicOdxType, self.diag_coded_type.base_data_type.from_string(self.coded_value_raw))
+        self._coded_value = self.diag_coded_type.base_data_type.from_string(self.coded_value_raw)
 
     @override
     def _build_odxlinks(self) -> dict[OdxLinkId, Any]: