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

odxtools/diagcommdataconnector.py

@@ -0,0 +1,61 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass
+from typing import Any
+from xml.etree import ElementTree
+
+from .exceptions import odxrequire
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkId
+from .readdiagcommconnector import ReadDiagCommConnector
+from .snrefcontext import SnRefContext
+from .utils import read_hex_binary
+from .writediagcommconnector import WriteDiagCommConnector
+
+
+@dataclass(kw_only=True)
+class DiagCommDataConnector:
+    uncompressed_size: int
+    source_start_address: int
+    read_diag_comm_connector: ReadDiagCommConnector | None = None
+    write_diag_comm_connector: WriteDiagCommConnector | None = None
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "DiagCommDataConnector":
+        uncompressed_size = int(odxrequire(et_element.findtext("UNCOMPRESSED-SIZE")))
+        source_start_address = odxrequire(read_hex_binary(et_element.find("SOURCE-START-ADDRESS")))
+
+        read_diag_comm_connector = None
+        if (rdcc_elem := et_element.find("READ-DIAG-COMM-CONNECTOR")) is not None:
+            read_diag_comm_connector = ReadDiagCommConnector.from_et(rdcc_elem, context)
+
+        write_diag_comm_connector = None
+        if (wdcc_elem := et_element.find("WRITE-DIAG-COMM-CONNECTOR")) is not None:
+            write_diag_comm_connector = WriteDiagCommConnector.from_et(wdcc_elem, context)
+
+        return DiagCommDataConnector(
+            uncompressed_size=uncompressed_size,
+            source_start_address=source_start_address,
+            read_diag_comm_connector=read_diag_comm_connector,
+            write_diag_comm_connector=write_diag_comm_connector)
+
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
+        odxlinks = {}
+
+        if self.read_diag_comm_connector is not None:
+            odxlinks.update(self.read_diag_comm_connector._build_odxlinks())
+        if self.write_diag_comm_connector is not None:
+            odxlinks.update(self.write_diag_comm_connector._build_odxlinks())
+
+        return odxlinks
+
+    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
+        if self.read_diag_comm_connector is not None:
+            self.read_diag_comm_connector._resolve_odxlinks(odxlinks)
+        if self.write_diag_comm_connector is not None:
+            self.write_diag_comm_connector._resolve_odxlinks(odxlinks)
+
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
+        if self.read_diag_comm_connector is not None:
+            self.read_diag_comm_connector._resolve_snrefs(context)
+        if self.write_diag_comm_connector is not None:
+            self.write_diag_comm_connector._resolve_snrefs(context)

odxtools/diaglayers/diaglayer.py

@@ -352,7 +352,7 @@ class DiagLayer:
             # corresponding request for `decode_response()`.)
             request_prefix = b''
             if s.request is not None:
-                request_prefix = s.request.coded_const_prefix()
+                request_prefix = bytes(s.request.coded_const_prefix())
             prefixes = [request_prefix]
             gnrs = getattr(self, "global_negative_responses", [])
             prefixes += [
@@ -383,7 +383,7 @@ class DiagLayer:
         else:
             cast(list[DiagService], sub_tree[-1]).append(service)
 
-    def _find_services_for_uds(self, message: bytes) -> list[DiagService]:
+    def _find_services_for_uds(self, message: bytes | bytearray) -> list[DiagService]:
         prefix_tree = self._prefix_tree
 
         # Find matching service(s) in prefix tree
@@ -398,7 +398,8 @@ class DiagLayer:
                 possible_services += cast(list[DiagService], prefix_tree[-1])
         return possible_services
 
-    def _decode(self, message: bytes, candidate_services: Iterable[DiagService]) -> list[Message]:
+    def _decode(self, message: bytes | bytearray,
+                candidate_services: Iterable[DiagService]) -> list[Message]:
         decoded_messages: list[Message] = []
 
         for service in candidate_services:
@@ -420,7 +421,7 @@ class DiagLayer:
 
                         decoded_messages.append(
                             Message(
-                                coded_message=message,
+                                coded_message=bytes(message),
                                 service=service,
                                 coding_object=gnr,
                                 param_dict=decoded_gnr))
@@ -437,12 +438,13 @@ class DiagLayer:
 
         return decoded_messages
 
-    def decode(self, message: bytes) -> list[Message]:
+    def decode(self, message: bytes | bytearray) -> list[Message]:
         candidate_services = self._find_services_for_uds(message)
 
         return self._decode(message, candidate_services)
 
-    def decode_response(self, response: bytes, request: bytes) -> list[Message]:
+    def decode_response(self, response: bytes | bytearray,
+                        request: bytes | bytearray) -> list[Message]:
         candidate_services = self._find_services_for_uds(request)
         if candidate_services is None:
             raise DecodeError(f"Couldn't find corresponding service for request {request.hex()}.")

odxtools/diagservice.py

@@ -179,13 +179,13 @@ class DiagService(DiagComm):
 
         self.request.print_free_parameters_info()
 
-    def decode_message(self, raw_message: bytes) -> Message:
+    def decode_message(self, raw_message: bytes | bytearray) -> Message:
         request_prefix = b''
         candidate_coding_objects: list[Request | Response] = [
             *self.positive_responses, *self.negative_responses
         ]
         if self.request is not None:
-            request_prefix = self.request.coded_const_prefix()
+            request_prefix = bytes(self.request.coded_const_prefix())
             candidate_coding_objects.append(self.request)
 
         coding_objects: list[Request | Response] = []
@@ -199,7 +199,7 @@ class DiagService(DiagComm):
             try:
                 result_list.append(
                     Message(
-                        coded_message=raw_message,
+                        coded_message=bytes(raw_message),
                         service=self,
                         coding_object=coding_object,
                         param_dict=coding_object.decode(raw_message)))
@@ -221,7 +221,7 @@ class DiagService(DiagComm):
 
         return result_list[0]
 
-    def encode_request(self, **kwargs: ParameterValue) -> bytes:
+    def encode_request(self, **kwargs: ParameterValue) -> bytearray:
         """Prepare an array of bytes ready to be send over the wire
         for the request of this service.
         """
@@ -229,7 +229,7 @@ class DiagService(DiagComm):
         # encoding are specified (parameters which have a default are
         # optional)
         if self.request is None:
-            return b''
+            return bytearray()
 
         missing_params = {x.short_name
                           for x in self.request.required_parameters}.difference(kwargs.keys())
@@ -245,18 +245,18 @@ class DiagService(DiagComm):
         return self.request.encode(**kwargs)
 
     def encode_positive_response(self,
-                                 coded_request: bytes,
+                                 coded_request: bytes | bytearray,
                                  response_index: int = 0,
-                                 **kwargs: ParameterValue) -> bytes:
+                                 **kwargs: ParameterValue) -> bytearray:
         # TODO: Should the user decide the positive response or what are the differences?
         return self.positive_responses[response_index].encode(coded_request, **kwargs)
 
     def encode_negative_response(self,
-                                 coded_request: bytes,
+                                 coded_request: bytes | bytearray,
                                  response_index: int = 0,
-                                 **kwargs: ParameterValue) -> bytes:
+                                 **kwargs: ParameterValue) -> bytearray:
         return self.negative_responses[response_index].encode(coded_request, **kwargs)
 
-    def __call__(self, **kwargs: ParameterValue) -> bytes:
+    def __call__(self, **kwargs: ParameterValue) -> bytearray:
         """Encode a request."""
         return self.encode_request(**kwargs)

odxtools/ecuconfig.py

@@ -0,0 +1,89 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any
+from xml.etree import ElementTree
+
+from .additionalaudience import AdditionalAudience
+from .configdata import ConfigData
+from .configdatadictionaryspec import ConfigDataDictionarySpec
+from .nameditemlist import NamedItemList
+from .odxcategory import OdxCategory
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkId
+from .snrefcontext import SnRefContext
+from .utils import dataclass_fields_asdict
+
+if TYPE_CHECKING:
+    from .database import Database
+
+
+@dataclass(kw_only=True)
+class EcuConfig(OdxCategory):
+    config_datas: NamedItemList[ConfigData]
+    additional_audiences: NamedItemList[AdditionalAudience]
+    config_data_dictionary_spec: ConfigDataDictionarySpec | None
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "EcuConfig":
+
+        base_obj = OdxCategory.from_et(et_element, context)
+        kwargs = dataclass_fields_asdict(base_obj)
+
+        config_datas = NamedItemList([
+            ConfigData.from_et(el, context)
+            for el in et_element.iterfind("CONFIG-DATAS/CONFIG-DATA")
+        ])
+        additional_audiences = NamedItemList([
+            AdditionalAudience.from_et(el, context)
+            for el in et_element.iterfind("ADDITIONAL-AUDIENCES/ADDITIONAL-AUDIENCE")
+        ])
+        config_data_dictionary_spec = None
+        if (cdd_elem := et_element.find("CONFIG-DATA-DICTIONARY-SPEC")) is not None:
+            config_data_dictionary_spec = ConfigDataDictionarySpec.from_et(cdd_elem, context)
+
+        return EcuConfig(
+            config_datas=config_datas,
+            additional_audiences=additional_audiences,
+            config_data_dictionary_spec=config_data_dictionary_spec,
+            **kwargs)
+
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
+        odxlinks = super()._build_odxlinks()
+
+        for config_data in self.config_datas:
+            odxlinks.update(config_data._build_odxlinks())
+
+        for additional_audience in self.additional_audiences:
+            odxlinks.update(additional_audience._build_odxlinks())
+
+        if self.config_data_dictionary_spec is not None:
+            odxlinks.update(self.config_data_dictionary_spec._build_odxlinks())
+
+        return odxlinks
+
+    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
+        super()._resolve_odxlinks(odxlinks)
+
+        for config_data in self.config_datas:
+            config_data._resolve_odxlinks(odxlinks)
+
+        for additional_audiences in self.additional_audiences:
+            additional_audiences._resolve_odxlinks(odxlinks)
+
+        if self.config_data_dictionary_spec is not None:
+            self.config_data_dictionary_spec._resolve_odxlinks(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 config_data in self.config_datas:
+            config_data._resolve_snrefs(context)
+
+        for additional_audiences in self.additional_audiences:
+            additional_audiences._resolve_snrefs(context)
+
+        if self.config_data_dictionary_spec is not None:
+            self.config_data_dictionary_spec._resolve_snrefs(context)

odxtools/encryptcompressmethod.py

@@ -6,17 +6,26 @@ from .encryptcompressmethodtype import EncryptCompressMethodType
 from .exceptions import odxraise, odxrequire
 from .odxdoccontext import OdxDocContext
 from .odxlink import OdxLinkDatabase, OdxLinkId
+from .odxtypes import AtomicOdxType, DataType
 from .snrefcontext import SnRefContext
 
 
 @dataclass(kw_only=True)
 class EncryptCompressMethod:
-    value: str
+    value_raw: str
     value_type: EncryptCompressMethodType
 
+    @property
+    def value(self) -> AtomicOdxType:
+        return self._value
+
+    @property
+    def data_type(self) -> DataType:
+        return self._data_type
+
     @staticmethod
     def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "EncryptCompressMethod":
-        value = et_element.text or ""
+        value_raw = et_element.text or ""
 
         value_type_str = odxrequire(et_element.attrib.get("TYPE"))
         try:
@@ -25,7 +34,11 @@ class EncryptCompressMethod:
             value_type = cast(EncryptCompressMethodType, None)
             odxraise(f"Encountered unknown addressing type '{value_type_str}'")
 
-        return EncryptCompressMethod(value=value, value_type=value_type)
+        return EncryptCompressMethod(value_raw=value_raw, value_type=value_type)
+
+    def __post_init__(self) -> None:
+        self._data_type = DataType(self.value_type.value)
+        self._value = self._data_type.from_string(self.value_raw.strip())
 
     def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         odxlinks: dict[OdxLinkId, Any] = {}

odxtools/externflashdata.py

@@ -1,10 +1,10 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import Any
+from typing import IO, Any
 from xml.etree import ElementTree
 
 from .datafile import Datafile
-from .exceptions import odxrequire
+from .exceptions import odxraise, odxrequire
 from .flashdata import Flashdata
 from .odxdoccontext import OdxDocContext
 from .odxlink import OdxLinkDatabase, OdxLinkId
@@ -16,6 +16,21 @@ from .utils import dataclass_fields_asdict
 class ExternFlashdata(Flashdata):
     datafile: Datafile
 
+    @property
+    def data_str(self) -> str:
+        if self._database is None:
+            odxraise("No database object specified")
+            return ""
+
+        aux_file: IO[bytes] = odxrequire(self._database.auxiliary_files.get(self.datafile.value))
+        if aux_file is None:
+            return ""
+
+        result = aux_file.read().decode()
+        aux_file.seek(0)
+
+        return result
+
     @staticmethod
     def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "ExternFlashdata":
         kwargs = dataclass_fields_asdict(Flashdata.from_et(et_element, context))
@@ -32,3 +47,7 @@ class ExternFlashdata(Flashdata):
 
     def _resolve_snrefs(self, context: SnRefContext) -> None:
         super()._resolve_snrefs(context)
+
+        # this is slightly hacky because we only remember the
+        # applicable ODX database and do not resolve any SNREFs here
+        self._database = context.database

odxtools/flashdata.py

@@ -1,12 +1,16 @@
 # SPDX-License-Identifier: MIT
+import re
 from dataclasses import dataclass
-from typing import Any
+from typing import Any, cast
 from xml.etree import ElementTree
 
+from bincopy import BinFile
+
 from .dataformat import Dataformat
+from .dataformatselection import DataformatSelection
 from .element import IdentifiableElement
 from .encryptcompressmethod import EncryptCompressMethod
-from .exceptions import odxrequire
+from .exceptions import odxassert, odxraise, odxrequire
 from .odxdoccontext import OdxDocContext
 from .odxlink import OdxLinkDatabase, OdxLinkId
 from .snrefcontext import SnRefContext
@@ -20,6 +24,40 @@ class Flashdata(IdentifiableElement):
     dataformat: Dataformat
     encrypt_compress_method: EncryptCompressMethod | None = None
 
+    @property
+    def data_str(self) -> str:
+        raise NotImplementedError(f"The .data_str property has not been implemented "
+                                  f"by the {type(self).__name__} class")
+
+    @property
+    def dataset(self) -> BinFile | bytearray | None:
+        data_str = self.data_str
+        if self.dataformat.selection in (DataformatSelection.INTEL_HEX,
+                                         DataformatSelection.MOTOROLA_S):
+            bf = BinFile()
+
+            # remove white space and empty lines
+            bf.add("\n".join([re.sub(r"\s", "", x) for x in data_str.splitlines() if x.strip()]))
+
+            return bf
+        elif self.dataformat.selection == DataformatSelection.BINARY:
+            return bytearray.fromhex(re.sub(r"\s", "", data_str, flags=re.MULTILINE))
+        else:
+            odxassert(self.dataformat.selection == DataformatSelection.USER_DEFINED,
+                      f"Unsupported data format {self.dataformat.selection}")
+            return None
+
+    @property
+    def blob(self) -> bytearray:
+        ds = self.dataset
+        if isinstance(ds, BinFile):
+            return cast(bytearray, ds.as_binary())
+        elif isinstance(ds, bytearray):
+            return ds
+
+        odxraise("USER-DEFINED flash data cannot be interpreted on the odxtools level")
+        return bytearray()
+
     @staticmethod
     def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "Flashdata":
 

odxtools/identvalue.py

@@ -5,6 +5,7 @@ from xml.etree import ElementTree
 from .exceptions import odxraise
 from .identvaluetype import IdentValueType
 from .odxdoccontext import OdxDocContext
+from .odxtypes import AtomicOdxType, DataType
 
 
 @dataclass(kw_only=True)
@@ -13,15 +14,23 @@ class IdentValue:
     Corresponds to IDENT-VALUE.
     """
 
-    value: str
+    value_raw: str
 
     # note that the spec says this attribute is named "TYPE", but in
     # python, "type" is a build-in function...
     value_type: IdentValueType
 
+    @property
+    def value(self) -> AtomicOdxType:
+        return self._value
+
+    @property
+    def data_type(self) -> DataType:
+        return self._data_type
+
     @staticmethod
     def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "IdentValue":
-        value = et_element.text or ""
+        value_raw = et_element.text or ""
 
         try:
             value_type = IdentValueType(et_element.attrib["TYPE"])
@@ -29,4 +38,8 @@ class IdentValue:
             odxraise(f"Cannot parse IDENT-VALUE-TYPE: {e}")
             value_type = None
 
-        return IdentValue(value=value, value_type=value_type)
+        return IdentValue(value_raw=value_raw, value_type=value_type)
+
+    def __post_init__(self) -> None:
+        self._data_type = DataType(self.value_type.value)
+        self._value = self._data_type.from_string(self.value_raw.strip())

odxtools/internflashdata.py

@@ -15,6 +15,10 @@ from .utils import dataclass_fields_asdict
 class InternFlashdata(Flashdata):
     data: str
 
+    @property
+    def data_str(self) -> str:
+        return self.data
+
     @staticmethod
     def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "InternFlashdata":
         kwargs = dataclass_fields_asdict(Flashdata.from_et(et_element, context))

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/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:
         """