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

odxtools/parameters/codedconstparameter.py

@@ -1,7 +1,7 @@
 # SPDX-License-Identifier: MIT
 import warnings
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Dict, List, Optional
+from typing import Any, Dict, List, Optional
 from xml.etree import ElementTree
 
 from typing_extensions import override
@@ -11,14 +11,11 @@ from ..decodestate import DecodeState
 from ..diagcodedtype import DiagCodedType
 from ..encodestate import EncodeState
 from ..exceptions import DecodeError, EncodeError, odxraise, odxrequire
-from ..odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
+from ..odxlink import OdxDocFragment, OdxLinkId
 from ..odxtypes import AtomicOdxType, DataType, ParameterValue
 from ..utils import dataclass_fields_asdict
 from .parameter import Parameter, ParameterType
 
-if TYPE_CHECKING:
-    from ..diaglayer import DiagLayer
-
 
 @dataclass
 class CodedConstParameter(Parameter):
@@ -54,15 +51,6 @@ class CodedConstParameter(Parameter):
 
         return result
 
-    @override
-    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
-        super()._resolve_odxlinks(odxlinks)
-
-    @override
-    def _parameter_resolve_snrefs(self, diag_layer: "DiagLayer", *,
-                                  param_list: List[Parameter]) -> None:
-        super()._parameter_resolve_snrefs(diag_layer, param_list=param_list)
-
     @override
     def get_static_bit_length(self) -> Optional[int]:
         return self.diag_coded_type.get_static_bit_length()

odxtools/parameters/lengthkeyparameter.py

@@ -1,6 +1,6 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Dict, List, Optional
+from typing import Any, Dict, List, Optional
 from xml.etree import ElementTree
 
 from typing_extensions import final, override
@@ -8,15 +8,12 @@ from typing_extensions import final, override
 from ..decodestate import DecodeState
 from ..encodestate import EncodeState
 from ..exceptions import EncodeError, odxraise, odxrequire
-from ..odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
+from ..odxlink import OdxDocFragment, OdxLinkId
 from ..odxtypes import ParameterValue
 from ..utils import dataclass_fields_asdict
-from .parameter import Parameter, ParameterType
+from .parameter import ParameterType
 from .parameterwithdop import ParameterWithDOP
 
-if TYPE_CHECKING:
-    from ..diaglayer import DiagLayer
-
 
 @dataclass
 class LengthKeyParameter(ParameterWithDOP):
@@ -55,15 +52,6 @@ class LengthKeyParameter(ParameterWithDOP):
 
         return result
 
-    @override
-    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
-        super()._resolve_odxlinks(odxlinks)
-
-    @override
-    def _parameter_resolve_snrefs(self, diag_layer: "DiagLayer", *,
-                                  param_list: List[Parameter]) -> None:
-        super()._parameter_resolve_snrefs(diag_layer, param_list=param_list)
-
     @property
     @override
     def is_required(self) -> bool:
@@ -107,7 +95,6 @@ class LengthKeyParameter(ParameterWithDOP):
 
             encode_state.length_keys[self.short_name] = physical_value
 
-        orig_cursor = encode_state.cursor_byte_position
         pos = encode_state.cursor_byte_position
         if self.byte_position is not None:
             pos = encode_state.origin_byte_position + self.byte_position
@@ -120,7 +107,6 @@ class LengthKeyParameter(ParameterWithDOP):
         tmp_val = b'\x00' * ((n + 7) // 8)
         encode_state.emplace_bytes(tmp_val, obj_used_mask=tmp_val)
 
-        encode_state.cursor_byte_position = max(encode_state.cursor_byte_position, orig_cursor)
         encode_state.cursor_bit_position = 0
 
     def encode_value_into_pdu(self, encode_state: EncodeState) -> None:

odxtools/parameters/nrcconstparameter.py

@@ -1,7 +1,6 @@
 # SPDX-License-Identifier: MIT
-import warnings
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Dict, List, Optional, cast
+from typing import Any, Dict, List, Optional
 from xml.etree import ElementTree
 
 from typing_extensions import override
@@ -10,19 +9,17 @@ from ..createanydiagcodedtype import create_any_diag_coded_type_from_et
 from ..decodestate import DecodeState
 from ..diagcodedtype import DiagCodedType
 from ..encodestate import EncodeState
-from ..exceptions import DecodeError, EncodeError, odxraise, odxrequire
-from ..odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
+from ..exceptions import DecodeMismatch, EncodeError, odxraise, odxrequire
+from ..odxlink import OdxDocFragment, OdxLinkId
 from ..odxtypes import AtomicOdxType, DataType, ParameterValue
 from ..utils import dataclass_fields_asdict
 from .parameter import Parameter, ParameterType
 
-if TYPE_CHECKING:
-    from ..diaglayer import DiagLayer
-
 
 @dataclass
 class NrcConstParameter(Parameter):
-    """A param of type NRC-CONST defines a set of values to be matched for a negative response to apply.
+    """A parameter of type NRC-CONST defines a set of values to be
+    matched for a negative response object to apply
 
     The behaviour of NRC-CONST parameters is similar to CODED-CONST
     parameters in that they allow to specify which coding objects
@@ -70,15 +67,6 @@ class NrcConstParameter(Parameter):
 
         return result
 
-    @override
-    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
-        super()._resolve_odxlinks(odxlinks)
-
-    @override
-    def _parameter_resolve_snrefs(self, diag_layer: "DiagLayer", *,
-                                  param_list: List[Parameter]) -> None:
-        super()._parameter_resolve_snrefs(diag_layer, param_list=param_list)
-
     @override
     def get_static_bit_length(self) -> Optional[int]:
         return self.diag_coded_type.get_static_bit_length()
@@ -100,49 +88,40 @@ class NrcConstParameter(Parameter):
     @override
     def _encode_positioned_into_pdu(self, physical_value: Optional[ParameterValue],
                                     encode_state: EncodeState) -> None:
-        coded_value: ParameterValue
+        # NRC-CONST parameters are not encoding any value on its
+        # own. instead, it is supposed to overlap with a value
+        # parameter.
         if physical_value is not None:
-            if physical_value not in self.coded_values:
-                odxraise(
-                    f"The value of parameter '{self.short_name}' must "
-                    f" be one of {self.coded_values} (is: {physical_value!r})", EncodeError)
-                coded_value = self.coded_values[0]
-            else:
-                coded_value = physical_value
-        else:
-            # If the user did not select a value, the value of the
-            # this parameter is set by another parameter which
-            # overlaps with it. We thus just move the cursor.
-            bit_pos = encode_state.cursor_bit_position
-            bit_len = self.diag_coded_type.get_static_bit_length()
-
-            if bit_len is None:
-                odxraise("The diag coded type of NRC-CONST parameters must "
-                         "exhibit a static size")
-                return
-
-            encode_state.cursor_byte_position += (bit_pos + bit_len + 7) // 8
-            encode_state.cursor_bit_position = 0
+            odxraise("The value of NRC-CONST parameters cannot be set directly!", EncodeError)
+
+        # TODO (?): extract the parameter and check if it is one of
+        # the values of self.coded_values. if not, throw an
+        # EncodeMismatch exception! This is probably a bad idea
+        # because the parameter which determines the value of the
+        # NRC-CONST might possibly be specified after the NRC-CONST.
+
+        # move the cursor forward by the size of the parameter
+        bit_pos = encode_state.cursor_bit_position
+        bit_len = self.diag_coded_type.get_static_bit_length()
+
+        if bit_len is None:
+            odxraise("The diag coded type of NRC-CONST parameters must "
+                     "exhibit a static size")
             return
 
-        self.diag_coded_type.encode_into_pdu(cast(AtomicOdxType, coded_value), encode_state)
+        encode_state.cursor_byte_position += (bit_pos + bit_len + 7) // 8
+        encode_state.cursor_bit_position = 0
+
+        encode_state.emplace_bytes(b'', self.short_name)
 
     @override
     def _decode_positioned_from_pdu(self, decode_state: DecodeState) -> AtomicOdxType:
-        # Extract coded values
+        # Extract coded value
         coded_value = self.diag_coded_type.decode_from_pdu(decode_state)
 
         # Check if the coded value in the message is correct.
         if coded_value not in self.coded_values:
-            warnings.warn(
-                f"Coded constant parameter does not match! "
-                f"The parameter {self.short_name} expected a coded "
-                f"value in {str(self.coded_values)} but got {str(coded_value)} "
-                f"at byte position {decode_state.cursor_byte_position} "
-                f"in coded message {decode_state.coded_message.hex()}.",
-                DecodeError,
-                stacklevel=1,
-            )
+            raise DecodeMismatch(f"NRC-CONST parameter {self.short_name} does not apply")
 
         return coded_value
 

odxtools/parameters/parameter.py

@@ -1,22 +1,19 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Dict, List, Literal, Optional
+from typing import Any, Dict, List, Literal, Optional
 from xml.etree import ElementTree
 
 from typing_extensions import final, override
 
-from ..createsdgs import create_sdgs_from_et
 from ..decodestate import DecodeState
 from ..element import NamedElement
 from ..encodestate import EncodeState
 from ..odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
 from ..odxtypes import ParameterValue
+from ..snrefcontext import SnRefContext
 from ..specialdatagroup import SpecialDataGroup
 from ..utils import dataclass_fields_asdict
 
-if TYPE_CHECKING:
-    from ..diaglayer import DiagLayer
-
 ParameterType = Literal[
     "CODED-CONST",
     "DYNAMIC",
@@ -55,7 +52,9 @@ class Parameter(NamedElement):
         kwargs = dataclass_fields_asdict(NamedElement.from_et(et_element, doc_frags))
 
         semantic = et_element.get("SEMANTIC")
-        sdgs = create_sdgs_from_et(et_element.find("SDGS"), doc_frags)
+        sdgs = [
+            SpecialDataGroup.from_et(sdge, doc_frags) for sdge in et_element.iterfind("SDGS/SDG")
+        ]
 
         byte_position_str = et_element.findtext("BYTE-POSITION")
         bit_position_str = et_element.findtext("BIT-POSITION")
@@ -82,15 +81,9 @@ class Parameter(NamedElement):
         for sdg in self.sdgs:
             sdg._resolve_odxlinks(odxlinks)
 
-    @final
-    def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
-        raise RuntimeError("Calling _resolve_snrefs() is not allowed for parameters. "
-                           "Use _parameter_resolve_snrefs() instead.")
-
-    def _parameter_resolve_snrefs(self, diag_layer: "DiagLayer", *,
-                                  param_list: List["Parameter"]) -> None:
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
         for sdg in self.sdgs:
-            sdg._resolve_snrefs(diag_layer)
+            sdg._resolve_snrefs(context)
 
     @property
     def parameter_type(self) -> ParameterType:
@@ -126,14 +119,15 @@ class Parameter(NamedElement):
     @final
     def encode_into_pdu(self, physical_value: Optional[ParameterValue],
                         encode_state: EncodeState) -> None:
-        """Convert a physical value into its encoded form and place it into the PDU
+        """Convert a physical value into its encoded form and place it
+        into the PDU
+
+        Also, adapt the `encode_state` so that it points to where the
+        next parameter is located (if the next parameter does not
+        explicitly specify a position)
 
-        Also, adapt the `encode_state` so that it points to where the next
-        parameter is located (if the parameter does not explicitly specify a
-        position)
         """
 
-        orig_cursor = encode_state.cursor_byte_position
         if self.byte_position is not None:
             encode_state.cursor_byte_position = encode_state.origin_byte_position + self.byte_position
 
@@ -141,7 +135,6 @@ class Parameter(NamedElement):
 
         self._encode_positioned_into_pdu(physical_value, encode_state)
 
-        encode_state.cursor_byte_position = max(encode_state.cursor_byte_position, orig_cursor)
         encode_state.cursor_bit_position = 0
 
     def _encode_positioned_into_pdu(self, physical_value: Optional[ParameterValue],
@@ -155,7 +148,15 @@ class Parameter(NamedElement):
 
     @final
     def decode_from_pdu(self, decode_state: DecodeState) -> ParameterValue:
-        orig_cursor = decode_state.cursor_byte_position
+        """Retrieve the raw data for the parameter from the PDU and
+        convert it to its physical interpretation
+
+        Also, adapt the `encode_state` so that it points to where the
+        next parameter is located (if the next parameter does not
+        explicitly specify a position)
+
+        """
+
         if self.byte_position is not None:
             decode_state.cursor_byte_position = decode_state.origin_byte_position + self.byte_position
 
@@ -163,7 +164,6 @@ class Parameter(NamedElement):
 
         result = self._decode_positioned_from_pdu(decode_state)
 
-        decode_state.cursor_byte_position = max(decode_state.cursor_byte_position, orig_cursor)
         decode_state.cursor_bit_position = 0
 
         return result

odxtools/parameters/parameterwithdop.py

@@ -1,6 +1,6 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Dict, List, Optional, cast
+from typing import Any, Dict, List, Optional, cast
 from xml.etree import ElementTree
 
 from typing_extensions import override
@@ -14,12 +14,10 @@ from ..exceptions import odxassert, odxrequire
 from ..odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef, resolve_snref
 from ..odxtypes import AtomicOdxType, ParameterValue
 from ..physicaltype import PhysicalType
+from ..snrefcontext import SnRefContext
 from ..utils import dataclass_fields_asdict
 from .parameter import Parameter
 
-if TYPE_CHECKING:
-    from ..diaglayer import DiagLayer
-
 
 @dataclass
 class ParameterWithDOP(Parameter):
@@ -58,12 +56,12 @@ class ParameterWithDOP(Parameter):
             self._dop = odxlinks.resolve(self.dop_ref)
 
     @override
-    def _parameter_resolve_snrefs(self, diag_layer: "DiagLayer", *,
-                                  param_list: List[Parameter]) -> None:
-        super()._parameter_resolve_snrefs(diag_layer, param_list=param_list)
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
+        super()._resolve_snrefs(context)
 
         if self.dop_snref:
-            all_dops = diag_layer.diag_data_dictionary_spec.all_data_object_properties
+            all_dops = odxrequire(
+                context.diag_layer).diag_data_dictionary_spec.all_data_object_properties
             self._dop = resolve_snref(self.dop_snref, all_dops, DopBase)
 
     @property

odxtools/parameters/physicalconstantparameter.py

@@ -1,6 +1,6 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Dict, List, Optional
+from typing import Any, Dict, List, Optional
 from xml.etree import ElementTree
 
 from typing_extensions import override
@@ -11,13 +11,11 @@ from ..encodestate import EncodeState
 from ..exceptions import DecodeError, EncodeError, odxraise, odxrequire
 from ..odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
 from ..odxtypes import ParameterValue
+from ..snrefcontext import SnRefContext
 from ..utils import dataclass_fields_asdict
-from .parameter import Parameter, ParameterType
+from .parameter import ParameterType
 from .parameterwithdop import ParameterWithDOP
 
-if TYPE_CHECKING:
-    from ..diaglayer import DiagLayer
-
 
 @dataclass
 class PhysicalConstantParameter(ParameterWithDOP):
@@ -50,9 +48,8 @@ class PhysicalConstantParameter(ParameterWithDOP):
         super()._resolve_odxlinks(odxlinks)
 
     @override
-    def _parameter_resolve_snrefs(self, diag_layer: "DiagLayer", *,
-                                  param_list: List[Parameter]) -> None:
-        super()._parameter_resolve_snrefs(diag_layer, param_list=param_list)
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
+        super()._resolve_snrefs(context)
 
         dop = odxrequire(self.dop)
         if not isinstance(dop, DataObjectProperty):

odxtools/parameters/reservedparameter.py

@@ -51,9 +51,10 @@ class ReservedParameter(Parameter):
     @override
     def _encode_positioned_into_pdu(self, physical_value: Optional[ParameterValue],
                                     encode_state: EncodeState) -> None:
-        raw_data = (0).to_bytes((encode_state.cursor_bit_position + self.bit_length + 7) // 8,
-                                "big")
-        encode_state.emplace_bytes(raw_data, self.short_name)
+        encode_state.cursor_byte_position += (encode_state.cursor_bit_position + self.bit_length +
+                                              7) // 8
+        encode_state.cursor_bit_position = 0
+        encode_state.emplace_bytes(b'', self.short_name)
 
     @override
     def _decode_positioned_from_pdu(self, decode_state: DecodeState) -> ParameterValue:

odxtools/parameters/systemparameter.py

@@ -26,7 +26,7 @@ class SystemParameter(ParameterWithDOP):
 
         kwargs = dataclass_fields_asdict(ParameterWithDOP.from_et(et_element, doc_frags))
 
-        sysparam = odxrequire(et_element.findtext("SYSPARAM"))
+        sysparam = odxrequire(et_element.get("SYSPARAM"))
 
         return SystemParameter(sysparam=sysparam, **kwargs)
 

odxtools/parameters/tablekeyparameter.py

@@ -10,11 +10,11 @@ from ..encodestate import EncodeState
 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
 
 if TYPE_CHECKING:
-    from ..diaglayer import DiagLayer
     from ..table import Table
     from ..tablerow import TableRow
 
@@ -56,8 +56,8 @@ class TableKeyParameter(Parameter):
             **kwargs)
 
     def __post_init__(self) -> None:
-        self._table: "Table"
-        self._table_row: Optional["TableRow"] = None
+        self._table: Table
+        self._table_row: Optional[TableRow] = None
         if self.table_ref is None and self.table_snref is None and \
            self.table_row_ref is None and self.table_row_snref is None:
             odxraise("Either a table or a table row must be defined.")
@@ -94,12 +94,11 @@ class TableKeyParameter(Parameter):
             self._table = self._table_row.table
 
     @override
-    def _parameter_resolve_snrefs(self, diag_layer: "DiagLayer", *,
-                                  param_list: List[Parameter]) -> None:
-        super()._parameter_resolve_snrefs(diag_layer, param_list=param_list)
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
+        super()._resolve_snrefs(context)
 
         if self.table_snref is not None:
-            tables = diag_layer.diag_data_dictionary_spec.tables
+            tables = odxrequire(context.diag_layer).diag_data_dictionary_spec.tables
             self._table = resolve_snref(self.table_snref, tables, Table)
         if self.table_row_snref is not None:
             # make sure that we know the table to which the table row
@@ -165,7 +164,6 @@ class TableKeyParameter(Parameter):
 
             encode_state.table_keys[self.short_name] = physical_value
 
-        orig_pos = encode_state.cursor_byte_position
         pos = encode_state.cursor_byte_position
         if self.byte_position is not None:
             pos = encode_state.origin_byte_position + self.byte_position
@@ -189,7 +187,6 @@ class TableKeyParameter(Parameter):
         tmp_val = b'\x00' * ((n + 7) // 8)
         encode_state.emplace_bytes(tmp_val, obj_used_mask=tmp_val)
 
-        encode_state.cursor_byte_position = max(orig_pos, encode_state.cursor_byte_position)
         encode_state.cursor_bit_position = 0
 
     def encode_value_into_pdu(self, encode_state: EncodeState) -> None:

odxtools/parameters/tablestructparameter.py

@@ -1,6 +1,6 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Dict, List, Optional, cast
+from typing import Any, Dict, List, Optional, cast
 from xml.etree import ElementTree
 
 from typing_extensions import override
@@ -10,13 +10,11 @@ from ..encodestate import EncodeState
 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):
@@ -60,12 +58,12 @@ class TableStructParameter(Parameter):
             self._table_key = odxlinks.resolve(self.table_key_ref, TableKeyParameter)
 
     @override
-    def _parameter_resolve_snrefs(self, diag_layer: "DiagLayer", *,
-                                  param_list: List[Parameter]) -> None:
-        super()._parameter_resolve_snrefs(diag_layer, param_list=param_list)
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
+        super()._resolve_snrefs(context)
 
         if self.table_key_snref is not None:
-            self._table_key = resolve_snref(self.table_key_snref, param_list, TableKeyParameter)
+            self._table_key = resolve_snref(self.table_key_snref, odxrequire(context.parameters),
+                                            TableKeyParameter)
 
     @property
     def table_key(self) -> TableKeyParameter:

odxtools/parameters/valueparameter.py

@@ -1,6 +1,6 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Dict, List, Optional
+from typing import Any, Dict, List, Optional
 from xml.etree import ElementTree
 
 from typing_extensions import override
@@ -10,13 +10,11 @@ from ..encodestate import EncodeState
 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 Parameter, ParameterType
+from .parameter import ParameterType
 from .parameterwithdop import ParameterWithDOP
 
-if TYPE_CHECKING:
-    from ..diaglayer import DiagLayer
-
 
 @dataclass
 class ValueParameter(ParameterWithDOP):
@@ -50,9 +48,8 @@ class ValueParameter(ParameterWithDOP):
         super()._resolve_odxlinks(odxlinks)
 
     @override
-    def _parameter_resolve_snrefs(self, diag_layer: "DiagLayer", *,
-                                  param_list: List[Parameter]) -> None:
-        super()._parameter_resolve_snrefs(diag_layer, param_list=param_list)
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
+        super()._resolve_snrefs(context)
 
         if self.physical_default_value_raw is not None:
             dop = odxrequire(self.dop)

odxtools/paramlengthinfotype.py

@@ -1,18 +1,20 @@
 # 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 EncodeError, 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
 
 
@@ -21,6 +23,17 @@ class ParamLengthInfoType(DiagCodedType):
 
     length_key_ref: OdxLinkRef
 
+    @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)
+
     @property
     def dct_type(self) -> DctType:
         return "PARAM-LENGTH-INFO-TYPE"
@@ -37,9 +50,9 @@ class ParamLengthInfoType(DiagCodedType):
         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":

odxtools/parentref.py

@@ -1,10 +1,13 @@
 # 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
@@ -76,5 +79,16 @@ class ParentRef:
         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, Optional
 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):
@@ -89,5 +87,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