odxtools 9.7.0__py3-none-any.whl → 10.1.0__py3-none-any.whl

odxtools/parameters/lengthkeyparameter.py

@@ -1,6 +1,6 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import Any, Dict, List, Optional
+from typing import Any
 from xml.etree import ElementTree
 
 from typing_extensions import final, override
@@ -8,14 +8,15 @@ from typing_extensions import final, override
 from ..decodestate import DecodeState
 from ..encodestate import EncodeState
 from ..exceptions import EncodeError, odxraise, odxrequire
-from ..odxlink import OdxDocFragment, OdxLinkId
+from ..odxdoccontext import OdxDocContext
+from ..odxlink import OdxLinkId
 from ..odxtypes import ParameterValue
 from ..utils import dataclass_fields_asdict
 from .parameter import ParameterType
 from .parameterwithdop import ParameterWithDOP
 
 
-@dataclass
+@dataclass(kw_only=True)
 class LengthKeyParameter(ParameterWithDOP):
     """Length Keys specify the bit (!) length of another parameter.
 
@@ -48,17 +49,16 @@ class LengthKeyParameter(ParameterWithDOP):
 
     @staticmethod
     @override
-    def from_et(et_element: ElementTree.Element,
-                doc_frags: List[OdxDocFragment]) -> "LengthKeyParameter":
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "LengthKeyParameter":
 
-        kwargs = dataclass_fields_asdict(ParameterWithDOP.from_et(et_element, doc_frags))
+        kwargs = dataclass_fields_asdict(ParameterWithDOP.from_et(et_element, context))
 
-        odx_id = odxrequire(OdxLinkId.from_et(et_element, doc_frags))
+        odx_id = odxrequire(OdxLinkId.from_et(et_element, context))
 
         return LengthKeyParameter(odx_id=odx_id, **kwargs)
 
     @override
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         result = super()._build_odxlinks()
 
         result[self.odx_id] = self
@@ -67,7 +67,7 @@ class LengthKeyParameter(ParameterWithDOP):
 
     @override
     @final
-    def _encode_positioned_into_pdu(self, physical_value: Optional[ParameterValue],
+    def _encode_positioned_into_pdu(self, physical_value: ParameterValue | None,
                                     encode_state: EncodeState) -> None:
         # if you get this exception, you ought to use
         # `.encode_placeholder_into_pdu()` followed by (after the
@@ -75,7 +75,7 @@ class LengthKeyParameter(ParameterWithDOP):
         # `.encode_value_into_pdu()`.
         raise RuntimeError("_encode_positioned_into_pdu() cannot be called for length keys.")
 
-    def encode_placeholder_into_pdu(self, physical_value: Optional[ParameterValue],
+    def encode_placeholder_into_pdu(self, physical_value: ParameterValue | None,
                                     encode_state: EncodeState) -> None:
 
         if physical_value is not None:

odxtools/parameters/matchingrequestparameter.py

@@ -1,6 +1,5 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import List, Optional
 from xml.etree import ElementTree
 
 from typing_extensions import override
@@ -8,13 +7,13 @@ from typing_extensions import override
 from ..decodestate import DecodeState
 from ..encodestate import EncodeState
 from ..exceptions import EncodeError, odxraise, odxrequire
-from ..odxlink import OdxDocFragment
+from ..odxdoccontext import OdxDocContext
 from ..odxtypes import DataType, ParameterValue
 from ..utils import dataclass_fields_asdict
 from .parameter import Parameter, ParameterType
 
 
-@dataclass
+@dataclass(kw_only=True)
 class MatchingRequestParameter(Parameter):
     request_byte_position: int
     byte_length: int
@@ -37,9 +36,9 @@ class MatchingRequestParameter(Parameter):
     @staticmethod
     @override
     def from_et(et_element: ElementTree.Element,
-                doc_frags: List[OdxDocFragment]) -> "MatchingRequestParameter":
+                context: OdxDocContext) -> "MatchingRequestParameter":
 
-        kwargs = dataclass_fields_asdict(Parameter.from_et(et_element, doc_frags))
+        kwargs = dataclass_fields_asdict(Parameter.from_et(et_element, context))
 
         request_byte_position = int(odxrequire(et_element.findtext("REQUEST-BYTE-POS")))
         byte_length = int(odxrequire(et_element.findtext("BYTE-LENGTH")))
@@ -48,11 +47,11 @@ class MatchingRequestParameter(Parameter):
             request_byte_position=request_byte_position, byte_length=byte_length, **kwargs)
 
     @override
-    def get_static_bit_length(self) -> Optional[int]:
+    def get_static_bit_length(self) -> int | None:
         return 8 * self.byte_length
 
     @override
-    def _encode_positioned_into_pdu(self, physical_value: Optional[ParameterValue],
+    def _encode_positioned_into_pdu(self, physical_value: ParameterValue | None,
                                     encode_state: EncodeState) -> None:
         if encode_state.triggering_request is None:
             odxraise(

odxtools/parameters/nrcconstparameter.py

@@ -1,6 +1,6 @@
 # SPDX-License-Identifier: MIT
-from dataclasses import dataclass
-from typing import Any, Dict, List, Optional
+from dataclasses import dataclass, field
+from typing import Any
 from xml.etree import ElementTree
 
 from typing_extensions import override
@@ -10,13 +10,14 @@ from ..decodestate import DecodeState
 from ..diagcodedtype import DiagCodedType
 from ..encodestate import EncodeState
 from ..exceptions import DecodeMismatch, EncodeError, odxraise, odxrequire
-from ..odxlink import OdxDocFragment, OdxLinkId
+from ..odxdoccontext import OdxDocContext
+from ..odxlink import OdxLinkId
 from ..odxtypes import AtomicOdxType, DataType, ParameterValue
 from ..utils import dataclass_fields_asdict
 from .parameter import Parameter, ParameterType
 
 
-@dataclass
+@dataclass(kw_only=True)
 class NrcConstParameter(Parameter):
     """A parameter of type NRC-CONST defines a set of values to be
     matched for a negative response object to apply
@@ -34,7 +35,7 @@ class NrcConstParameter(Parameter):
 
     """
 
-    coded_values_raw: List[str]
+    coded_values_raw: list[str] = field(default_factory=list)
     diag_coded_type: DiagCodedType
 
     @property
@@ -57,21 +58,20 @@ class NrcConstParameter(Parameter):
         return self.diag_coded_type.base_data_type
 
     @property
-    def coded_values(self) -> List[AtomicOdxType]:
+    def coded_values(self) -> list[AtomicOdxType]:
         return self._coded_values
 
     @staticmethod
     @override
-    def from_et(et_element: ElementTree.Element,
-                doc_frags: List[OdxDocFragment]) -> "NrcConstParameter":
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "NrcConstParameter":
 
-        kwargs = dataclass_fields_asdict(Parameter.from_et(et_element, doc_frags))
+        kwargs = dataclass_fields_asdict(Parameter.from_et(et_element, context))
 
         coded_values_raw = [
             odxrequire(x.text) for x in et_element.iterfind("CODED-VALUES/CODED-VALUE")
         ]
         dct_elem = odxrequire(et_element.find("DIAG-CODED-TYPE"))
-        diag_coded_type = create_any_diag_coded_type_from_et(dct_elem, doc_frags)
+        diag_coded_type = create_any_diag_coded_type_from_et(dct_elem, context)
 
         return NrcConstParameter(
             coded_values_raw=coded_values_raw, diag_coded_type=diag_coded_type, **kwargs)
@@ -82,7 +82,7 @@ class NrcConstParameter(Parameter):
         ]
 
     @override
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         result = super()._build_odxlinks()
 
         result.update(self.diag_coded_type._build_odxlinks())
@@ -90,11 +90,11 @@ class NrcConstParameter(Parameter):
         return result
 
     @override
-    def get_static_bit_length(self) -> Optional[int]:
+    def get_static_bit_length(self) -> int | None:
         return self.diag_coded_type.get_static_bit_length()
 
     @override
-    def _encode_positioned_into_pdu(self, physical_value: Optional[ParameterValue],
+    def _encode_positioned_into_pdu(self, physical_value: ParameterValue | None,
                                     encode_state: EncodeState) -> None:
         # NRC-CONST parameters are not encoding any value on its
         # own. instead, it is supposed to overlap with a value

odxtools/parameters/parameter.py

@@ -1,6 +1,6 @@
 # SPDX-License-Identifier: MIT
-from dataclasses import dataclass
-from typing import Any, Dict, List, Literal, Optional
+from dataclasses import dataclass, field
+from typing import Any, Literal
 from xml.etree import ElementTree
 
 from typing_extensions import final, override
@@ -8,7 +8,8 @@ from typing_extensions import final, override
 from ..decodestate import DecodeState
 from ..element import NamedElement
 from ..encodestate import EncodeState
-from ..odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
+from ..odxdoccontext import OdxDocContext
+from ..odxlink import OdxLinkDatabase, OdxLinkId
 from ..odxtypes import ParameterValue
 from ..snrefcontext import SnRefContext
 from ..specialdatagroup import SpecialDataGroup
@@ -30,7 +31,7 @@ ParameterType = Literal[
 ]
 
 
-@dataclass
+@dataclass(kw_only=True)
 class Parameter(NamedElement):
     """This class corresponds to POSITIONABLE-PARAM in the ODX
     specification
@@ -42,11 +43,11 @@ class Parameter(NamedElement):
     non-positionable parameter types.
 
     """
-    sdgs: List[SpecialDataGroup]
-    semantic: Optional[str]
-    oid: Optional[str]
-    byte_position: Optional[int]
-    bit_position: Optional[int]
+    sdgs: list[SpecialDataGroup] = field(default_factory=list)
+    semantic: str | None = None
+    oid: str | None = None
+    byte_position: int | None = None
+    bit_position: int | None = None
 
     @property
     def parameter_type(self) -> ParameterType:
@@ -78,13 +79,11 @@ class Parameter(NamedElement):
 
     @staticmethod
     @override
-    def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "Parameter":
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "Parameter":
 
-        kwargs = dataclass_fields_asdict(NamedElement.from_et(et_element, doc_frags))
+        kwargs = dataclass_fields_asdict(NamedElement.from_et(et_element, context))
 
-        sdgs = [
-            SpecialDataGroup.from_et(sdge, doc_frags) for sdge in et_element.iterfind("SDGS/SDG")
-        ]
+        sdgs = [SpecialDataGroup.from_et(sdge, context) for sdge in et_element.iterfind("SDGS/SDG")]
         semantic = et_element.attrib.get("SEMANTIC")
         oid = et_element.attrib.get("OID")
         byte_position_str = et_element.findtext("BYTE-POSITION")
@@ -100,7 +99,7 @@ class Parameter(NamedElement):
             bit_position=bit_position,
             **kwargs)
 
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         result = {}
 
         for sdg in self.sdgs:
@@ -116,11 +115,11 @@ class Parameter(NamedElement):
         for sdg in self.sdgs:
             sdg._resolve_snrefs(context)
 
-    def get_static_bit_length(self) -> Optional[int]:
+    def get_static_bit_length(self) -> int | None:
         return None
 
     @final
-    def encode_into_pdu(self, physical_value: Optional[ParameterValue],
+    def encode_into_pdu(self, physical_value: ParameterValue | None,
                         encode_state: EncodeState) -> None:
         """Convert a physical value into its encoded form and place it
         into the PDU
@@ -140,7 +139,7 @@ class Parameter(NamedElement):
 
         encode_state.cursor_bit_position = 0
 
-    def _encode_positioned_into_pdu(self, physical_value: Optional[ParameterValue],
+    def _encode_positioned_into_pdu(self, physical_value: ParameterValue | None,
                                     encode_state: EncodeState) -> None:
         """Method which actually encodes the parameter
 

odxtools/parameters/parameterwithdop.py

@@ -1,6 +1,6 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import Any, Dict, List, Optional, cast
+from typing import Any, cast
 from xml.etree import ElementTree
 
 from typing_extensions import override
@@ -11,7 +11,8 @@ from ..dopbase import DopBase
 from ..dtcdop import DtcDop
 from ..encodestate import EncodeState
 from ..exceptions import odxassert, odxrequire
-from ..odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef, resolve_snref
+from ..odxdoccontext import OdxDocContext
+from ..odxlink import OdxLinkDatabase, OdxLinkId, OdxLinkRef, resolve_snref
 from ..odxtypes import AtomicOdxType, ParameterValue
 from ..physicaltype import PhysicalType
 from ..snrefcontext import SnRefContext
@@ -19,10 +20,10 @@ from ..utils import dataclass_fields_asdict
 from .parameter import Parameter
 
 
-@dataclass
+@dataclass(kw_only=True)
 class ParameterWithDOP(Parameter):
-    dop_ref: Optional[OdxLinkRef]
-    dop_snref: Optional[str]
+    dop_ref: OdxLinkRef | None = None
+    dop_snref: str | None = None
 
     @property
     def dop(self) -> DopBase:
@@ -32,12 +33,11 @@ class ParameterWithDOP(Parameter):
 
     @staticmethod
     @override
-    def from_et(et_element: ElementTree.Element,
-                doc_frags: List[OdxDocFragment]) -> "ParameterWithDOP":
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "ParameterWithDOP":
 
-        kwargs = dataclass_fields_asdict(Parameter.from_et(et_element, doc_frags))
+        kwargs = dataclass_fields_asdict(Parameter.from_et(et_element, context))
 
-        dop_ref = OdxLinkRef.from_et(et_element.find("DOP-REF"), doc_frags)
+        dop_ref = OdxLinkRef.from_et(et_element.find("DOP-REF"), context)
         dop_snref = None
         if (dop_snref_elem := et_element.find("DOP-SNREF")) is not None:
             dop_snref = odxrequire(dop_snref_elem.get("SHORT-NAME"))
@@ -50,7 +50,7 @@ class ParameterWithDOP(Parameter):
         self._dop: DopBase
 
     @override
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         return super()._build_odxlinks()
 
     @override
@@ -70,21 +70,21 @@ class ParameterWithDOP(Parameter):
             self._dop = resolve_snref(self.dop_snref, ddds.all_data_object_properties, DopBase)
 
     @override
-    def get_static_bit_length(self) -> Optional[int]:
+    def get_static_bit_length(self) -> int | None:
         if self._dop is not None:
             return self._dop.get_static_bit_length()
         else:
             return None
 
     @property
-    def physical_type(self) -> Optional[PhysicalType]:
+    def physical_type(self) -> PhysicalType | None:
         if isinstance(self.dop, (DataObjectProperty, DtcDop)):
             return self.dop.physical_type
         else:
             return None
 
     @override
-    def _encode_positioned_into_pdu(self, physical_value: Optional[ParameterValue],
+    def _encode_positioned_into_pdu(self, physical_value: ParameterValue | None,
                                     encode_state: EncodeState) -> None:
         self.dop.encode_into_pdu(cast(AtomicOdxType, physical_value), encode_state)
 

odxtools/parameters/physicalconstantparameter.py

@@ -1,6 +1,6 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import Any, Dict, List, Optional
+from typing import Any
 from xml.etree import ElementTree
 
 from typing_extensions import override
@@ -9,7 +9,8 @@ from ..dataobjectproperty import DataObjectProperty
 from ..decodestate import DecodeState
 from ..encodestate import EncodeState
 from ..exceptions import DecodeError, EncodeError, odxraise, odxrequire
-from ..odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
+from ..odxdoccontext import OdxDocContext
+from ..odxlink import OdxLinkDatabase, OdxLinkId
 from ..odxtypes import ParameterValue
 from ..snrefcontext import SnRefContext
 from ..utils import dataclass_fields_asdict
@@ -17,7 +18,7 @@ from .parameter import ParameterType
 from .parameterwithdop import ParameterWithDOP
 
 
-@dataclass
+@dataclass(kw_only=True)
 class PhysicalConstantParameter(ParameterWithDOP):
     physical_constant_value_raw: str
 
@@ -43,9 +44,9 @@ class PhysicalConstantParameter(ParameterWithDOP):
     @staticmethod
     @override
     def from_et(et_element: ElementTree.Element,
-                doc_frags: List[OdxDocFragment]) -> "PhysicalConstantParameter":
+                context: OdxDocContext) -> "PhysicalConstantParameter":
 
-        kwargs = dataclass_fields_asdict(ParameterWithDOP.from_et(et_element, doc_frags))
+        kwargs = dataclass_fields_asdict(ParameterWithDOP.from_et(et_element, context))
 
         physical_constant_value_raw = odxrequire(et_element.findtext("PHYS-CONSTANT-VALUE"))
 
@@ -53,7 +54,7 @@ class PhysicalConstantParameter(ParameterWithDOP):
             physical_constant_value_raw=physical_constant_value_raw, **kwargs)
 
     @override
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         return super()._build_odxlinks()
 
     @override
@@ -72,7 +73,7 @@ class PhysicalConstantParameter(ParameterWithDOP):
         self._physical_constant_value = base_data_type.from_string(self.physical_constant_value_raw)
 
     @override
-    def _encode_positioned_into_pdu(self, physical_value: Optional[ParameterValue],
+    def _encode_positioned_into_pdu(self, physical_value: ParameterValue | None,
                                     encode_state: EncodeState) -> None:
         if physical_value is not None and physical_value != self.physical_constant_value:
             odxraise(

odxtools/parameters/reservedparameter.py

@@ -1,6 +1,5 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import List, Optional
 from xml.etree import ElementTree
 
 from typing_extensions import override
@@ -8,13 +7,13 @@ from typing_extensions import override
 from ..decodestate import DecodeState
 from ..encodestate import EncodeState
 from ..exceptions import odxrequire
-from ..odxlink import OdxDocFragment
+from ..odxdoccontext import OdxDocContext
 from ..odxtypes import DataType, ParameterValue
 from ..utils import dataclass_fields_asdict
 from .parameter import Parameter, ParameterType
 
 
-@dataclass
+@dataclass(kw_only=True)
 class ReservedParameter(Parameter):
     bit_length: int
 
@@ -35,20 +34,19 @@ class ReservedParameter(Parameter):
 
     @staticmethod
     @override
-    def from_et(et_element: ElementTree.Element,
-                doc_frags: List[OdxDocFragment]) -> "ReservedParameter":
-        kwargs = dataclass_fields_asdict(Parameter.from_et(et_element, doc_frags))
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "ReservedParameter":
+        kwargs = dataclass_fields_asdict(Parameter.from_et(et_element, context))
 
         bit_length = int(odxrequire(et_element.findtext("BIT-LENGTH")))
 
         return ReservedParameter(bit_length=bit_length, **kwargs)
 
     @override
-    def get_static_bit_length(self) -> Optional[int]:
+    def get_static_bit_length(self) -> int | None:
         return self.bit_length
 
     @override
-    def _encode_positioned_into_pdu(self, physical_value: Optional[ParameterValue],
+    def _encode_positioned_into_pdu(self, physical_value: ParameterValue | None,
                                     encode_state: EncodeState) -> None:
         encode_state.cursor_byte_position += (encode_state.cursor_bit_position + self.bit_length +
                                               7) // 8

odxtools/parameters/systemparameter.py

@@ -2,14 +2,13 @@
 import getpass
 from dataclasses import dataclass
 from datetime import datetime
-from typing import List, Optional
 from xml.etree import ElementTree
 
 from typing_extensions import override
 
 from ..encodestate import EncodeState
 from ..exceptions import odxraise, odxrequire
-from ..odxlink import OdxDocFragment
+from ..odxdoccontext import OdxDocContext
 from ..odxtypes import ParameterValue
 from ..utils import dataclass_fields_asdict
 from .parameter import ParameterType
@@ -25,7 +24,7 @@ PREDEFINED_SYSPARAM_VALUES = [
 ]
 
 
-@dataclass
+@dataclass(kw_only=True)
 class SystemParameter(ParameterWithDOP):
     sysparam: str
 
@@ -49,16 +48,15 @@ class SystemParameter(ParameterWithDOP):
 
     @staticmethod
     @override
-    def from_et(et_element: ElementTree.Element,
-                doc_frags: List[OdxDocFragment]) -> "SystemParameter":
-        kwargs = dataclass_fields_asdict(ParameterWithDOP.from_et(et_element, doc_frags))
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "SystemParameter":
+        kwargs = dataclass_fields_asdict(ParameterWithDOP.from_et(et_element, context))
 
         sysparam = odxrequire(et_element.get("SYSPARAM"))
 
         return SystemParameter(sysparam=sysparam, **kwargs)
 
     @override
-    def _encode_positioned_into_pdu(self, physical_value: Optional[ParameterValue],
+    def _encode_positioned_into_pdu(self, physical_value: ParameterValue | None,
                                     encode_state: EncodeState) -> None:
         if physical_value is None:
             # determine the value to be encoded automatically

odxtools/parameters/tableentryparameter.py

@@ -1,6 +1,6 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, List, Optional, cast
+from typing import TYPE_CHECKING, cast
 from xml.etree import ElementTree
 
 from typing_extensions import override
@@ -8,7 +8,8 @@ from typing_extensions import override
 from ..decodestate import DecodeState
 from ..encodestate import EncodeState
 from ..exceptions import odxraise, odxrequire
-from ..odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkRef
+from ..odxdoccontext import OdxDocContext
+from ..odxlink import OdxLinkDatabase, OdxLinkRef
 from ..odxtypes import ParameterValue
 from ..utils import dataclass_fields_asdict
 from .parameter import Parameter, ParameterType
@@ -18,7 +19,7 @@ if TYPE_CHECKING:
     from ..tablerow import TableRow
 
 
-@dataclass
+@dataclass(kw_only=True)
 class TableEntryParameter(Parameter):
     target: RowFragment
     table_row_ref: OdxLinkRef
@@ -44,9 +45,8 @@ class TableEntryParameter(Parameter):
 
     @staticmethod
     @override
-    def from_et(et_element: ElementTree.Element,
-                doc_frags: List[OdxDocFragment]) -> "TableEntryParameter":
-        kwargs = dataclass_fields_asdict(Parameter.from_et(et_element, doc_frags))
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "TableEntryParameter":
+        kwargs = dataclass_fields_asdict(Parameter.from_et(et_element, context))
 
         target_str = odxrequire(et_element.findtext("TARGET"))
         try:
@@ -54,7 +54,7 @@ class TableEntryParameter(Parameter):
         except ValueError:
             odxraise(f"Encountered unknown target '{target_str}'")
             target = cast(RowFragment, None)
-        table_row_ref = odxrequire(OdxLinkRef.from_et(et_element.find("TABLE-ROW-REF"), doc_frags))
+        table_row_ref = odxrequire(OdxLinkRef.from_et(et_element.find("TABLE-ROW-REF"), context))
 
         return TableEntryParameter(target=target, table_row_ref=table_row_ref, **kwargs)
 
@@ -68,7 +68,7 @@ class TableEntryParameter(Parameter):
             self._table_row = odxlinks.resolve(self.table_row_ref)
 
     @override
-    def _encode_positioned_into_pdu(self, physical_value: Optional[ParameterValue],
+    def _encode_positioned_into_pdu(self, physical_value: ParameterValue | None,
                                     encode_state: EncodeState) -> None:
         raise NotImplementedError("Encoding a TableEntryParameter is not implemented yet.")
 

odxtools/parameters/tablekeyparameter.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 TYPE_CHECKING, Any, Optional
 from xml.etree import ElementTree
 
 from typing_extensions import final, override
@@ -8,7 +8,8 @@ from typing_extensions import final, override
 from ..decodestate import DecodeState
 from ..encodestate import EncodeState
 from ..exceptions import DecodeError, EncodeError, odxraise, odxrequire
-from ..odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef, resolve_snref
+from ..odxdoccontext import OdxDocContext
+from ..odxlink import OdxLinkDatabase, OdxLinkId, OdxLinkRef, resolve_snref
 from ..odxtypes import ParameterValue
 from ..snrefcontext import SnRefContext
 from ..utils import dataclass_fields_asdict
@@ -19,35 +20,34 @@ if TYPE_CHECKING:
     from ..tablerow import TableRow
 
 
-@dataclass
+@dataclass(kw_only=True)
 class TableKeyParameter(Parameter):
 
     odx_id: OdxLinkId
 
     # the spec mandates that exactly one of the two attributes must
     # be non-None
-    table_ref: Optional[OdxLinkRef]
-    table_snref: Optional[str]
+    table_ref: OdxLinkRef | None = None
+    table_snref: str | None = None
 
     # the spec mandates that exactly one of the two attributes must
     # be non-None
-    table_row_ref: Optional[OdxLinkRef]
-    table_row_snref: Optional[str]
+    table_row_ref: OdxLinkRef | None = None
+    table_row_snref: str | None = None
 
     @staticmethod
     @override
-    def from_et(et_element: ElementTree.Element,
-                doc_frags: List[OdxDocFragment]) -> "TableKeyParameter":
-        kwargs = dataclass_fields_asdict(Parameter.from_et(et_element, doc_frags))
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "TableKeyParameter":
+        kwargs = dataclass_fields_asdict(Parameter.from_et(et_element, context))
 
-        odx_id = odxrequire(OdxLinkId.from_et(et_element, doc_frags))
+        odx_id = odxrequire(OdxLinkId.from_et(et_element, context))
 
-        table_ref = OdxLinkRef.from_et(et_element.find("TABLE-REF"), doc_frags)
+        table_ref = OdxLinkRef.from_et(et_element.find("TABLE-REF"), context)
         table_snref = None
         if (table_snref_elem := et_element.find("TABLE-SNREF")) is not None:
             table_snref = odxrequire(table_snref_elem.get("SHORT-NAME"))
 
-        table_row_ref = OdxLinkRef.from_et(et_element.find("TABLE-ROW-REF"), doc_frags)
+        table_row_ref = OdxLinkRef.from_et(et_element.find("TABLE-ROW-REF"), context)
         table_row_snref = None
         if (table_row_snref_elem := et_element.find("TABLE-ROW-SNREF")) is not None:
             table_row_snref = odxrequire(table_row_snref_elem.get("SHORT-NAME"))
@@ -62,7 +62,7 @@ class TableKeyParameter(Parameter):
 
     def __post_init__(self) -> None:
         self._table: Table
-        self._table_row: Optional[TableRow] = None
+        self._table_row: TableRow | None = None
 
     @property
     @override
@@ -70,7 +70,7 @@ class TableKeyParameter(Parameter):
         return "TABLE-KEY"
 
     @override
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         result = super()._build_odxlinks()
 
         result[self.odx_id] = self
@@ -143,7 +143,7 @@ class TableKeyParameter(Parameter):
 
     @override
     @final
-    def _encode_positioned_into_pdu(self, physical_value: Optional[ParameterValue],
+    def _encode_positioned_into_pdu(self, physical_value: ParameterValue | None,
                                     encode_state: EncodeState) -> None:
         # if you get this exception, you ought to use
         # `.encode_placeholder_into_pdu()` followed by (after the
@@ -151,7 +151,7 @@ class TableKeyParameter(Parameter):
         # `.encode_value_into_pdu()`.
         raise RuntimeError("_encode_positioned_into_pdu() cannot be called for table keys.")
 
-    def encode_placeholder_into_pdu(self, physical_value: Optional[ParameterValue],
+    def encode_placeholder_into_pdu(self, physical_value: ParameterValue | None,
                                     encode_state: EncodeState) -> None:
 
         if physical_value is not None: