odxtools 6.6.1__py3-none-any.whl → 9.3.0__py3-none-any.whl

odxtools/parameters/tablestructparameter.py

@@ -1,19 +1,20 @@
 # SPDX-License-Identifier: MIT
-import warnings
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Dict, Optional, cast
+from typing import Any, Dict, List, Optional, cast
+from xml.etree import ElementTree
+
+from typing_extensions import override
 
 from ..decodestate import DecodeState
 from ..encodestate import EncodeState
-from ..exceptions import EncodeError, OdxWarning, odxraise
-from ..odxlink import OdxLinkDatabase, OdxLinkId, OdxLinkRef
+from ..exceptions import DecodeError, EncodeError, odxraise, odxrequire
+from ..odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef, resolve_snref
 from ..odxtypes import ParameterValue
+from ..snrefcontext import SnRefContext
+from ..utils import dataclass_fields_asdict
 from .parameter import Parameter, ParameterType
 from .tablekeyparameter import TableKeyParameter
 
-if TYPE_CHECKING:
-    from ..diaglayer import DiagLayer
-
 
 @dataclass
 class TableStructParameter(Parameter):
@@ -21,123 +22,146 @@ class TableStructParameter(Parameter):
     table_key_ref: Optional[OdxLinkRef]
     table_key_snref: Optional[str]
 
+    @staticmethod
+    @override
+    def from_et(et_element: ElementTree.Element,
+                doc_frags: List[OdxDocFragment]) -> "TableStructParameter":
+
+        kwargs = dataclass_fields_asdict(Parameter.from_et(et_element, doc_frags))
+
+        table_key_ref = OdxLinkRef.from_et(et_element.find("TABLE-KEY-REF"), doc_frags)
+        table_key_snref = None
+        if (table_key_snref_elem := et_element.find("TABLE-KEY-SNREF")) is not None:
+            table_key_snref = odxrequire(table_key_snref_elem.get("SHORT-NAME"))
+
+        return TableStructParameter(
+            table_key_ref=table_key_ref, table_key_snref=table_key_snref, **kwargs)
+
     def __post_init__(self) -> None:
         if self.table_key_ref is None and self.table_key_snref is None:
             odxraise("Either table_key_ref or table_key_snref must be defined.")
 
     @property
+    @override
     def parameter_type(self) -> ParameterType:
         return "TABLE-STRUCT"
 
+    @override
     def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
         return super()._build_odxlinks()
 
+    @override
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
         super()._resolve_odxlinks(odxlinks)
 
         if self.table_key_ref is not None:
-            self._table_key = odxlinks.resolve(self.table_key_ref)
+            self._table_key = odxlinks.resolve(self.table_key_ref, TableKeyParameter)
 
-    def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
-        super()._resolve_snrefs(diag_layer)
+    @override
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
+        super()._resolve_snrefs(context)
 
         if self.table_key_snref is not None:
-            warnings.warn(
-                "Table keys cannot yet be defined using SNREFs"
-                " in TableStructParameters.",
-                OdxWarning,
-                stacklevel=1)
+            self._table_key = resolve_snref(self.table_key_snref, odxrequire(context.parameters),
+                                            TableKeyParameter)
 
     @property
     def table_key(self) -> TableKeyParameter:
         return self._table_key
 
     @property
+    @override
     def is_required(self) -> bool:
         return True
 
     @property
+    @override
     def is_settable(self) -> bool:
         return True
 
-    def get_coded_value_as_bytes(self, encode_state: EncodeState) -> bytes:
-        physical_value = encode_state.parameter_values.get(self.short_name)
+    @override
+    def _encode_positioned_into_pdu(self, physical_value: Optional[ParameterValue],
+                                    encode_state: EncodeState) -> None:
 
-        if not isinstance(physical_value, tuple) or \
+        if not isinstance(physical_value, (tuple, list)) or \
            len(physical_value) != 2 or \
            not isinstance(physical_value[0], str):
-            raise EncodeError(f"The physical value of TableStructParameter 'self.short_name' "
-                              f"must be a tuple with  the short name of the selected table "
-                              f"row as the first element and the physical value for the "
-                              f"row's structure or DOP as the second.")
+            odxraise(
+                f"The physical value of TableStructParameter 'self.short_name' "
+                f"must be a tuple containing the short name of the selected table "
+                f"row as the first element and the physical value for the "
+                f"row's structure or DOP as the second.", EncodeError)
 
         tr_short_name = physical_value[0]
 
         # make sure that the same table row is selected for all
         # TABLE-STRUCT parameters that are using the same key
         tk_short_name = self.table_key.short_name
-        tk_value = encode_state.parameter_values.get(tk_short_name)
+        tk_value = encode_state.table_keys.get(tk_short_name)
         if tk_value is None:
             # no value for the key has been set yet. Set it to the
             # value which we are using right now
-            encode_state.parameter_values[tk_short_name] = tr_short_name
+            encode_state.table_keys[tk_short_name] = tr_short_name
         elif tk_value != tr_short_name:
-            raise EncodeError(f"Cannot determine a unique value for table key '{tk_short_name}':  "
-                              f"Requested are '{tk_value}' and '{tr_short_name}'")
+            odxraise(
+                f"Cannot determine a unique value for table key '{tk_short_name}':  "
+                f"Requested are '{tk_value}' and '{tr_short_name}'", EncodeError)
+            return
 
         # deal with the static case (i.e., the table row is selected
         # by the table key object itself)
-        if self.table_key.table_row is not None and \
-           self.table_key.table_row.short_name != tr_short_name:
-            raise EncodeError(f"The selected table row for the {self.short_name} "
-                              f"parameter must be '{self.table_key.table_row.short_name}' "
-                              f"(is: '{tr_short_name}')")
+        if self.table_key.table_row is not None:
+            if tr_short_name is not None and self.table_key.table_row.short_name != tr_short_name:
+                odxraise(
+                    f"The selected table row for the {self.short_name} "
+                    f"parameter must be '{self.table_key.table_row.short_name}' "
+                    f"instead of '{tr_short_name}'", EncodeError)
+                return
+
+            tr_short_name = self.table_key.table_row.short_name
 
         # encode the user specified value using the structure (or DOP)
         # of the selected table row
         table = self.table_key.table
         candidate_trs = [tr for tr in table.table_rows if tr.short_name == tr_short_name]
-        if len(candidate_trs) != 1:
-            raise EncodeError(f"Could not uniquely resolve a table row named "
-                              f"'{tr_short_name}' in table '{table.short_name}' ")
+        if len(candidate_trs) == 0:
+            odxraise(
+                f"Could not find a table row named "
+                f"'{tr_short_name}' in table '{table.short_name}'", EncodeError)
+            return
+        elif len(candidate_trs) > 1:
+            odxraise(
+                f"Found multiple table rows named "
+                f"'{tr_short_name}' in table '{table.short_name}'", EncodeError)
+
         tr = candidate_trs[0]
         tr_value = physical_value[1]
 
-        bit_position = self.bit_position or 0
         if tr.structure is not None:
             # the selected table row references a structure
-            inner_encode_state = EncodeState(
-                coded_message=bytearray(b''),
-                parameter_values=tr_value,
-                triggering_request=encode_state.triggering_request)
-
-            return tr.structure.convert_physical_to_bytes(
-                tr_value, inner_encode_state, bit_position=bit_position)
+            tr.structure.encode_into_pdu(tr_value, encode_state)
+            return
 
         # if the table row does not reference a structure, it must
         # point to a DOP!
         if tr.dop is None:
-            odxraise()
-
-        return tr.dop.convert_physical_to_bytes(
-            tr_value, encode_state=encode_state, bit_position=bit_position)
-
-    def encode_into_pdu(self, encode_state: EncodeState) -> bytes:
-        return super().encode_into_pdu(encode_state)
+            odxraise(f"Neither a structure nor a DOP has been defined for table row"
+                     f"'{tr.short_name}'")
+            return
 
-    def decode_from_pdu(self, decode_state: DecodeState) -> ParameterValue:
-        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
+        tr.dop.encode_into_pdu(tr_value, encode_state)
 
+    @override
+    def _decode_positioned_from_pdu(self, decode_state: DecodeState) -> ParameterValue:
         # find the selected table row
         key_name = self.table_key.short_name
 
         decode_state.table_keys[key_name]
         table_row = decode_state.table_keys.get(key_name)
         if table_row is None:
-            raise odxraise(f"No table key '{key_name}' found when decoding "
-                           f"table struct parameter '{str(self.short_name)}'")
+            odxraise(
+                f"No table key '{key_name}' found when decoding "
+                f"table struct parameter '{str(self.short_name)}'", DecodeError)
             dummy_val = cast(str, None), cast(int, None)
             return dummy_val
 
@@ -145,14 +169,11 @@ class TableStructParameter(Parameter):
         if table_row.dop is not None:
             dop = table_row.dop
             val = dop.decode_from_pdu(decode_state)
-            decode_state.cursor_byte_position = max(decode_state.cursor_byte_position, orig_cursor)
             return (table_row.short_name, val)
         elif table_row.structure is not None:
             val = table_row.structure.decode_from_pdu(decode_state)
-            decode_state.cursor_byte_position = max(decode_state.cursor_byte_position, orig_cursor)
             return (table_row.short_name, val)
         else:
             # the table row associated with the key neither defines a
             # DOP nor a structure -> ignore it
-            decode_state.cursor_byte_position = max(decode_state.cursor_byte_position, orig_cursor)
             return (table_row.short_name, cast(int, None))

odxtools/parameters/valueparameter.py

@@ -1,18 +1,20 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Dict, Optional
+from typing import Any, Dict, List, Optional
+from xml.etree import ElementTree
+
+from typing_extensions import override
 
 from ..dataobjectproperty import DataObjectProperty
 from ..encodestate import EncodeState
-from ..exceptions import odxraise, odxrequire
-from ..odxlink import OdxLinkDatabase, OdxLinkId
-from ..odxtypes import AtomicOdxType
+from ..exceptions import EncodeError, odxraise, odxrequire
+from ..odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
+from ..odxtypes import AtomicOdxType, ParameterValue
+from ..snrefcontext import SnRefContext
+from ..utils import dataclass_fields_asdict
 from .parameter import ParameterType
 from .parameterwithdop import ParameterWithDOP
 
-if TYPE_CHECKING:
-    from ..diaglayer import DiagLayer
-
 
 @dataclass
 class ValueParameter(ParameterWithDOP):
@@ -21,18 +23,33 @@ class ValueParameter(ParameterWithDOP):
     def __post_init__(self) -> None:
         self._physical_default_value: Optional[AtomicOdxType] = None
 
+    @staticmethod
+    @override
+    def from_et(et_element: ElementTree.Element,
+                doc_frags: List[OdxDocFragment]) -> "ValueParameter":
+
+        kwargs = dataclass_fields_asdict(ParameterWithDOP.from_et(et_element, doc_frags))
+
+        physical_default_value_raw = et_element.findtext("PHYSICAL-DEFAULT-VALUE")
+
+        return ValueParameter(physical_default_value_raw=physical_default_value_raw, **kwargs)
+
     @property
+    @override
     def parameter_type(self) -> ParameterType:
         return "VALUE"
 
+    @override
     def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
         return super()._build_odxlinks()
 
+    @override
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
         super()._resolve_odxlinks(odxlinks)
 
-    def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
-        super()._resolve_snrefs(diag_layer)
+    @override
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
+        super()._resolve_snrefs(context)
 
         if self.physical_default_value_raw is not None:
             dop = odxrequire(self.dop)
@@ -48,23 +65,24 @@ class ValueParameter(ParameterWithDOP):
         return self._physical_default_value
 
     @property
+    @override
     def is_required(self) -> bool:
         return self._physical_default_value is None
 
     @property
+    @override
     def is_settable(self) -> bool:
         return True
 
-    def get_coded_value_as_bytes(self, encode_state: EncodeState) -> bytes:
-        physical_value = encode_state.parameter_values.get(self.short_name,
-                                                           self.physical_default_value)
+    @override
+    def _encode_positioned_into_pdu(self, physical_value: Optional[ParameterValue],
+                                    encode_state: EncodeState) -> None:
+
         if physical_value is None:
-            raise TypeError(f"A value for parameter '{self.short_name}' must be specified"
-                            f" as the parameter does not exhibit a default.")
-        dop = odxrequire(
-            self.dop,
-            f"Param {self.short_name} does not have a DOP. Maybe resolving references failed?")
-
-        bit_position_int = self.bit_position if self.bit_position is not None else 0
-        return dop.convert_physical_to_bytes(
-            physical_value, encode_state=encode_state, bit_position=bit_position_int)
+            physical_value = self._physical_default_value
+        if physical_value is None:
+            odxraise(
+                f"A value for parameter '{self.short_name}' must be specified"
+                f" because the parameter does not exhibit a default.", EncodeError)
+
+        self.dop.encode_into_pdu(physical_value, encode_state=encode_state)

odxtools/paramlengthinfotype.py

@@ -1,28 +1,46 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Dict, cast
+from typing import TYPE_CHECKING, Any, Dict, List, cast
+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 odxraise
-from .odxlink import OdxLinkDatabase, OdxLinkId, OdxLinkRef
+from .exceptions import EncodeError, odxraise, odxrequire
+from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef
 from .odxtypes import AtomicOdxType, DataType
+from .snrefcontext import SnRefContext
+from .utils import dataclass_fields_asdict
 
 if TYPE_CHECKING:
-    from .diaglayer import DiagLayer
     from .parameters.lengthkeyparameter import LengthKeyParameter
 
 
 @dataclass
 class ParamLengthInfoType(DiagCodedType):
-
     length_key_ref: OdxLinkRef
 
     @property
     def dct_type(self) -> DctType:
         return "PARAM-LENGTH-INFO-TYPE"
 
+    @property
+    def length_key(self) -> "LengthKeyParameter":
+        return self._length_key
+
+    @staticmethod
+    @override
+    def from_et(et_element: ElementTree.Element,
+                doc_frags: List[OdxDocFragment]) -> "ParamLengthInfoType":
+        kwargs = dataclass_fields_asdict(DiagCodedType.from_et(et_element, doc_frags))
+
+        length_key_ref = odxrequire(
+            OdxLinkRef.from_et(et_element.find("LENGTH-KEY-REF"), doc_frags))
+
+        return ParamLengthInfoType(length_key_ref=length_key_ref, **kwargs)
+
     def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
         return super()._build_odxlinks()
 
@@ -30,45 +48,52 @@ class ParamLengthInfoType(DiagCodedType):
         """Recursively resolve any odxlinks references"""
         super()._resolve_odxlinks(odxlinks)
 
-        self._length_key = odxlinks.resolve(self.length_key_ref)
+        if TYPE_CHECKING:
+            self._length_key = odxlinks.resolve(self.length_key_ref, LengthKeyParameter)
+        else:
+            self._length_key = odxlinks.resolve(self.length_key_ref)
 
-    def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
         """Recursively resolve any short-name references"""
-        super()._resolve_snrefs(diag_layer)
+        super()._resolve_snrefs(context)
 
-    @property
-    def length_key(self) -> "LengthKeyParameter":
-        return self._length_key
-
-    def convert_internal_to_bytes(self, internal_value: AtomicOdxType, encode_state: EncodeState,
-                                  bit_position: int) -> bytes:
-        bit_length = encode_state.parameter_values.get(self.length_key.short_name, None)
+    @override
+    def encode_into_pdu(self, internal_value: AtomicOdxType, encode_state: EncodeState) -> None:
+        bit_length = encode_state.length_keys.get(self.length_key.short_name)
 
         if bit_length is None:
+            # the length key is implicit, i.e., we need to set the
+            # value for the length key in the encode_state based on
+            # the value passed here.
             if self.base_data_type in [
                     DataType.A_BYTEFIELD,
                     DataType.A_ASCIISTRING,
                     DataType.A_UTF8STRING,
             ]:
-                bit_length = 8 * len(internal_value)  # type: ignore[arg-type]
-            if self.base_data_type in [DataType.A_UNICODE2STRING]:
-                bit_length = 16 * len(internal_value)  # type: ignore[arg-type]
-
-            if self.base_data_type in [DataType.A_INT32, DataType.A_UINT32]:
+                bit_length = 8 * len(cast(str, internal_value))
+            elif self.base_data_type in [DataType.A_UNICODE2STRING]:
+                bit_length = 16 * len(cast(str, internal_value))
+            elif self.base_data_type in [DataType.A_INT32, DataType.A_UINT32]:
                 bit_length = int(internal_value).bit_length()
                 if self.base_data_type == DataType.A_INT32:
                     bit_length += 1
                 # Round up
                 bit_length = ((bit_length + 7) // 8) * 8
-
-            encode_state.parameter_values[self.length_key.short_name] = bit_length
-
-        if bit_length is None:
-            odxraise()
-
-        return self._encode_internal_value(
-            internal_value,
-            bit_position=bit_position,
+            elif self.base_data_type == DataType.A_FLOAT32:
+                bit_length = 32
+            elif self.base_data_type == DataType.A_FLOAT64:
+                bit_length = 64
+            else:
+                odxraise(
+                    f"Cannot determine size of an object of type "
+                    f"{self.base_data_type.value}", EncodeError)
+                return
+
+            encode_state.length_keys[self.length_key.short_name] = bit_length
+
+        encode_state.emplace_atomic_value(
+            internal_value=internal_value,
+            used_mask=None,
             bit_length=bit_length,
             base_data_type=self.base_data_type,
             is_highlow_byte_order=self.is_highlow_byte_order,
@@ -79,7 +104,7 @@ class ParamLengthInfoType(DiagCodedType):
         if self.length_key.short_name not in decode_state.length_keys:
             odxraise(f"Unspecified mandatory length key parameter "
                      f"{self.length_key.short_name}")
-            decode_state.cursor_bit_position = None
+            decode_state.cursor_bit_position = 0
             return cast(None, AtomicOdxType)
 
         bit_length = decode_state.length_keys[self.length_key.short_name]
@@ -88,10 +113,8 @@ class ParamLengthInfoType(DiagCodedType):
             bit_length = 0
 
         # Extract the internal value and return.
-        value = decode_state.extract_atomic_value(
+        return decode_state.extract_atomic_value(
             bit_length,
             self.base_data_type,
             self.is_highlow_byte_order,
         )
-
-        return value

odxtools/parentref.py

@@ -1,13 +1,16 @@
 # SPDX-License-Identifier: MIT
+from copy import deepcopy
 from dataclasses import dataclass
 from typing import TYPE_CHECKING, Any, Dict, List
 from xml.etree import ElementTree
 
 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
+    from .diaglayers.diaglayer import DiagLayer
 
 
 @dataclass
@@ -71,7 +74,21 @@ class ParentRef:
         return {}
 
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
-        self._layer = odxlinks.resolve(self.layer_ref)
+        if TYPE_CHECKING:
+            self._layer = odxlinks.resolve(self.layer_ref, DiagLayer)
+        else:
+            self._layer = odxlinks.resolve(self.layer_ref)
 
-    def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
         pass
+
+    def __deepcopy__(self, memo: Dict[int, Any]) -> Any:
+        cls = self.__class__
+        result = cls.__new__(cls)
+        memo[id(self)] = result
+
+        fields = dataclass_fields_asdict(self)
+        for name, value in fields.items():
+            setattr(result, name, deepcopy(value))
+
+        return result

odxtools/physicaldimension.py

@@ -1,15 +1,13 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Dict, List, Optional
+from typing import Any, Dict, List
 from xml.etree import ElementTree
 
 from .element import IdentifiableElement
 from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
+from .snrefcontext import SnRefContext
 from .utils import dataclass_fields_asdict
 
-if TYPE_CHECKING:
-    from .diaglayer import DiagLayer
-
 
 @dataclass
 class PhysicalDimension(IdentifiableElement):
@@ -43,7 +41,6 @@ class PhysicalDimension(IdentifiableElement):
     )
     ```
     """
-    oid: Optional[str]
     length_exp: int
     mass_exp: int
     time_exp: int
@@ -56,7 +53,6 @@ class PhysicalDimension(IdentifiableElement):
     def from_et(et_element: ElementTree.Element,
                 doc_frags: List[OdxDocFragment]) -> "PhysicalDimension":
         kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, doc_frags))
-        oid = et_element.get("OID")
 
         def read_optional_int(element: ElementTree.Element, name: str) -> int:
             if val_str := element.findtext(name):
@@ -73,7 +69,6 @@ class PhysicalDimension(IdentifiableElement):
         luminous_intensity_exp = read_optional_int(et_element, "LUMINOUS-INTENSITY-EXP")
 
         return PhysicalDimension(
-            oid=oid,
             length_exp=length_exp,
             mass_exp=mass_exp,
             time_exp=time_exp,
@@ -89,5 +84,5 @@ class PhysicalDimension(IdentifiableElement):
     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/progcode.py

@@ -1,25 +1,33 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Dict, List, Optional
+from typing import Any, Dict, List, Optional, cast
 from xml.etree import ElementTree
 
-from .exceptions import odxrequire
+from .exceptions import odxraise, odxrequire
+from .library import Library
+from .nameditemlist import NamedItemList
 from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef
-
-if TYPE_CHECKING:
-    from .diaglayer import DiagLayer
+from .snrefcontext import SnRefContext
 
 
 @dataclass
 class ProgCode:
     """A reference to code that is executed by a single ECU job"""
     code_file: str
+    encryption: Optional[str]
     syntax: str
     revision: str
-    encryption: Optional[str]
     entrypoint: Optional[str]
     library_refs: List[OdxLinkRef]
 
+    @property
+    def code(self) -> bytes:
+        return self._code
+
+    @property
+    def libraries(self) -> NamedItemList[Library]:
+        return self._libraries
+
     @staticmethod
     def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "ProgCode":
         code_file = odxrequire(et_element.findtext("CODE-FILE"))
@@ -47,9 +55,16 @@ class ProgCode:
         return {}
 
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
-        # TODO: Libraries are currently not internalized.
-        #       Once they are internalized, resolve the `library_refs` references here.
-        pass
+        self._libraries = NamedItemList([odxlinks.resolve(x, Library) for x in self.library_refs])
+
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
+        aux_file = odxrequire(context.database).auxiliary_files.get(self.code_file)
+
+        if aux_file is None:
+            odxraise(f"Reference to auxiliary file '{self.code_file}' "
+                     f"could not be resolved")
+            self._code: bytes = cast(bytes, None)
+            return
 
-    def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
-        pass
+        self._code = aux_file.read()
+        aux_file.seek(0)

odxtools/protstack.py

@@ -1,6 +1,6 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Dict, List
+from typing import Any, Dict, List
 from xml.etree import ElementTree
 
 from .comparamsubset import ComparamSubset
@@ -8,11 +8,9 @@ from .element import IdentifiableElement
 from .exceptions import odxrequire
 from .nameditemlist import NamedItemList
 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 ProtStack(IdentifiableElement):
@@ -47,7 +45,7 @@ class ProtStack(IdentifiableElement):
         self._comparam_subsets = NamedItemList[ComparamSubset](
             [odxlinks.resolve(x, ComparamSubset) for x in self.comparam_subset_refs])
 
-    def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
         pass
 
     @property