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

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 TYPE_CHECKING, Any, 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 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,10 +20,10 @@ if TYPE_CHECKING:
     from ..table import Table
 
 
-@dataclass
+@dataclass(kw_only=True)
 class TableStructParameter(Parameter):
-    table_key_ref: Optional[OdxLinkRef]
-    table_key_snref: Optional[str]
+    table_key_ref: OdxLinkRef | None = None
+    table_key_snref: str | None = None
 
     @property
     @override
@@ -49,12 +50,11 @@ class TableStructParameter(Parameter):
 
     @staticmethod
     @override
-    def from_et(et_element: ElementTree.Element,
-                doc_frags: List[OdxDocFragment]) -> "TableStructParameter":
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "TableStructParameter":
 
-        kwargs = dataclass_fields_asdict(Parameter.from_et(et_element, doc_frags))
+        kwargs = dataclass_fields_asdict(Parameter.from_et(et_element, context))
 
-        table_key_ref = OdxLinkRef.from_et(et_element.find("TABLE-KEY-REF"), doc_frags)
+        table_key_ref = OdxLinkRef.from_et(et_element.find("TABLE-KEY-REF"), context)
         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"))
@@ -67,7 +67,7 @@ class TableStructParameter(Parameter):
             odxraise("Either table_key_ref or table_key_snref must be defined.")
 
     @override
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         return super()._build_odxlinks()
 
     @override
@@ -86,7 +86,7 @@ class TableStructParameter(Parameter):
                                             TableKeyParameter)
 
     @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 not isinstance(physical_value, (tuple, list)) or \

odxtools/parameters/valueparameter.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
@@ -8,7 +8,8 @@ from typing_extensions import override
 from ..dataobjectproperty import DataObjectProperty
 from ..encodestate import EncodeState
 from ..exceptions import EncodeError, odxraise, odxrequire
-from ..odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
+from ..odxdoccontext import OdxDocContext
+from ..odxlink import OdxLinkDatabase, OdxLinkId
 from ..odxtypes import AtomicOdxType, ParameterValue
 from ..snrefcontext import SnRefContext
 from ..utils import dataclass_fields_asdict
@@ -16,9 +17,9 @@ from .parameter import ParameterType
 from .parameterwithdop import ParameterWithDOP
 
 
-@dataclass
+@dataclass(kw_only=True)
 class ValueParameter(ParameterWithDOP):
-    physical_default_value_raw: Optional[str]
+    physical_default_value_raw: str | None = None
 
     @property
     @override
@@ -26,7 +27,7 @@ class ValueParameter(ParameterWithDOP):
         return "VALUE"
 
     @property
-    def physical_default_value(self) -> Optional[AtomicOdxType]:
+    def physical_default_value(self) -> AtomicOdxType | None:
         return self._physical_default_value
 
     @property
@@ -41,20 +42,19 @@ class ValueParameter(ParameterWithDOP):
 
     @staticmethod
     @override
-    def from_et(et_element: ElementTree.Element,
-                doc_frags: List[OdxDocFragment]) -> "ValueParameter":
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "ValueParameter":
 
-        kwargs = dataclass_fields_asdict(ParameterWithDOP.from_et(et_element, doc_frags))
+        kwargs = dataclass_fields_asdict(ParameterWithDOP.from_et(et_element, context))
 
         physical_default_value_raw = et_element.findtext("PHYSICAL-DEFAULT-VALUE")
 
         return ValueParameter(physical_default_value_raw=physical_default_value_raw, **kwargs)
 
     def __post_init__(self) -> None:
-        self._physical_default_value: Optional[AtomicOdxType] = None
+        self._physical_default_value: AtomicOdxType | None = None
 
     @override
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         return super()._build_odxlinks()
 
     @override
@@ -75,7 +75,7 @@ class ValueParameter(ParameterWithDOP):
                 self.physical_default_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 None:

odxtools/paramlengthinfotype.py

@@ -1,6 +1,6 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Dict, List, cast
+from typing import TYPE_CHECKING, Any, cast
 from xml.etree import ElementTree
 
 from typing_extensions import override
@@ -9,7 +9,8 @@ from .decodestate import DecodeState
 from .diagcodedtype import DctType, DiagCodedType
 from .encodestate import EncodeState
 from .exceptions import EncodeError, odxraise, odxrequire
-from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkId, OdxLinkRef
 from .odxtypes import AtomicOdxType, DataType
 from .snrefcontext import SnRefContext
 from .utils import dataclass_fields_asdict
@@ -18,7 +19,7 @@ if TYPE_CHECKING:
     from .parameters.lengthkeyparameter import LengthKeyParameter
 
 
-@dataclass
+@dataclass(kw_only=True)
 class ParamLengthInfoType(DiagCodedType):
     length_key_ref: OdxLinkRef
 
@@ -32,16 +33,14 @@ class ParamLengthInfoType(DiagCodedType):
 
     @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))
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "ParamLengthInfoType":
+        kwargs = dataclass_fields_asdict(DiagCodedType.from_et(et_element, context))
 
-        length_key_ref = odxrequire(
-            OdxLinkRef.from_et(et_element.find("LENGTH-KEY-REF"), doc_frags))
+        length_key_ref = odxrequire(OdxLinkRef.from_et(et_element.find("LENGTH-KEY-REF"), context))
 
         return ParamLengthInfoType(length_key_ref=length_key_ref, **kwargs)
 
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         return super()._build_odxlinks()
 
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
@@ -74,6 +73,8 @@ class ParamLengthInfoType(DiagCodedType):
             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]:
+                if not isinstance(internal_value, int):
+                    odxraise()
                 bit_length = int(internal_value).bit_length()
                 if self.base_data_type == DataType.A_INT32:
                     bit_length += 1

odxtools/parentref.py

@@ -1,11 +1,12 @@
 # SPDX-License-Identifier: MIT
 from copy import deepcopy
-from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Dict, List
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, Any
 from xml.etree import ElementTree
 
 from .exceptions import odxrequire
-from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkId, OdxLinkRef
 from .snrefcontext import SnRefContext
 from .utils import dataclass_fields_asdict
 
@@ -13,23 +14,24 @@ if TYPE_CHECKING:
     from .diaglayers.diaglayer import DiagLayer
 
 
-@dataclass
+@dataclass(kw_only=True)
 class ParentRef:
     layer_ref: OdxLinkRef
-    not_inherited_diag_comms: List[str]  # short_name references
-    not_inherited_variables: List[str]  # short_name references
-    not_inherited_dops: List[str]  # short_name references
-    not_inherited_tables: List[str]  # short_name references
-    not_inherited_global_neg_responses: List[str]  # short_name references
+    not_inherited_diag_comms: list[str] = field(default_factory=list)  # short_name references
+    not_inherited_variables: list[str] = field(default_factory=list)  # short_name references
+    not_inherited_dops: list[str] = field(default_factory=list)  # short_name references
+    not_inherited_tables: list[str] = field(default_factory=list)  # short_name references
+    not_inherited_global_neg_responses: list[str] = field(
+        default_factory=list)  # short_name references
 
     @property
     def layer(self) -> "DiagLayer":
         return self._layer
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "ParentRef":
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "ParentRef":
 
-        layer_ref = odxrequire(OdxLinkRef.from_et(et_element, doc_frags))
+        layer_ref = odxrequire(OdxLinkRef.from_et(et_element, context))
 
         not_inherited_diag_comms = [
             odxrequire(el.get("SHORT-NAME"))
@@ -69,7 +71,7 @@ class ParentRef:
             not_inherited_global_neg_responses=not_inherited_global_neg_responses,
         )
 
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         return {}
 
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
@@ -81,7 +83,7 @@ class ParentRef:
     def _resolve_snrefs(self, context: SnRefContext) -> None:
         pass
 
-    def __deepcopy__(self, memo: Dict[int, Any]) -> Any:
+    def __deepcopy__(self, memo: dict[int, Any]) -> Any:
         cls = self.__class__
         result = cls.__new__(cls)
         memo[id(self)] = result

odxtools/physicaldimension.py

@@ -1,15 +1,16 @@
 # 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 .element import IdentifiableElement
-from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkId
 from .snrefcontext import SnRefContext
 from .utils import dataclass_fields_asdict
 
 
-@dataclass
+@dataclass(kw_only=True)
 class PhysicalDimension(IdentifiableElement):
     """A physical dimension is a formal definition of a unit.
 
@@ -41,20 +42,19 @@ class PhysicalDimension(IdentifiableElement):
     )
     ```
     """
-    length_exp: Optional[int]
-    mass_exp: Optional[int]
-    time_exp: Optional[int]
-    current_exp: Optional[int]
-    temperature_exp: Optional[int]
-    molar_amount_exp: Optional[int]
-    luminous_intensity_exp: Optional[int]
+    length_exp: int | None = None
+    mass_exp: int | None = None
+    time_exp: int | None = None
+    current_exp: int | None = None
+    temperature_exp: int | None = None
+    molar_amount_exp: int | None = None
+    luminous_intensity_exp: int | None = None
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element,
-                doc_frags: List[OdxDocFragment]) -> "PhysicalDimension":
-        kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, doc_frags))
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "PhysicalDimension":
+        kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, context))
 
-        def read_optional_int(element: ElementTree.Element, name: str) -> Optional[int]:
+        def read_optional_int(element: ElementTree.Element, name: str) -> int | None:
             if (val_str := element.findtext(name)) is not None:
                 return int(val_str)
             else:
@@ -78,7 +78,7 @@ class PhysicalDimension(IdentifiableElement):
             luminous_intensity_exp=luminous_intensity_exp,
             **kwargs)
 
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         return {self.odx_id: self}
 
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:

odxtools/physicaltype.py

@@ -1,15 +1,14 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import List, Optional
 from xml.etree import ElementTree
 
 from .exceptions import odxraise
-from .odxlink import OdxDocFragment
+from .odxdoccontext import OdxDocContext
 from .odxtypes import DataType
 from .radix import Radix
 
 
-@dataclass
+@dataclass(kw_only=True)
 class PhysicalType:
     """The physical type describes the base data type of a parameter.
 
@@ -32,20 +31,20 @@ class PhysicalType:
     PhysicalType(DataType.A_FLOAT64, precision=2)
     """
 
-    precision: Optional[int]
+    precision: int | None = None
     """Number of digits after the decimal point to display to the user
     The precision is only applicable if the base data type is A_FLOAT32 or A_FLOAT64.
     """
 
     base_data_type: DataType
 
-    display_radix: Optional[Radix]
+    display_radix: Radix | None = None
     """The display radix defines how integers are displayed to the user.
     The display radix is only applicable if the base data type is A_UINT32.
     """
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "PhysicalType":
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "PhysicalType":
         precision_str = et_element.findtext("PRECISION")
         precision = int(precision_str) if precision_str is not None else None
 

odxtools/posresponsesuppressible.py

@@ -1,34 +1,33 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import List, Optional
 from xml.etree import ElementTree
 
 from .exceptions import odxrequire
-from .odxlink import OdxDocFragment
+from .odxdoccontext import OdxDocContext
 from .utils import read_hex_binary
 
 
 # note that the spec has a typo here: it calls the corresponding
 # XML tag POS-RESPONSE-SUPPRESSABLE...
-@dataclass
+@dataclass(kw_only=True)
 class PosResponseSuppressible:
     bit_mask: int
 
-    coded_const_snref: Optional[str]
-    coded_const_snpathref: Optional[str]
+    coded_const_snref: str | None = None
+    coded_const_snpathref: str | None = None
 
-    value_snref: Optional[str]
-    value_snpathref: Optional[str]
+    value_snref: str | None = None
+    value_snpathref: str | None = None
 
-    phys_const_snref: Optional[str]
-    phys_const_snpathref: Optional[str]
+    phys_const_snref: str | None = None
+    phys_const_snpathref: str | None = None
 
-    table_key_snref: Optional[str]
-    table_key_snpathref: Optional[str]
+    table_key_snref: str | None = None
+    table_key_snpathref: str | None = None
 
     @staticmethod
     def from_et(et_element: ElementTree.Element,
-                doc_frags: List[OdxDocFragment]) -> "PosResponseSuppressible":
+                context: OdxDocContext) -> "PosResponseSuppressible":
 
         bit_mask = odxrequire(read_hex_binary(et_element.find("BIT-MASK")))
 

odxtools/preconditionstateref.py

@@ -1,10 +1,11 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Dict, List, Optional
+from typing import TYPE_CHECKING, Any
 from xml.etree import ElementTree
 
 from .exceptions import odxassert, odxrequire
-from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkId, OdxLinkRef
 from .odxtypes import ParameterValueDict
 from .parameters.parameter import Parameter
 from .snrefcontext import SnRefContext
@@ -16,15 +17,15 @@ if TYPE_CHECKING:
     from .statemachine import StateMachine
 
 
-@dataclass
+@dataclass(kw_only=True)
 class PreConditionStateRef(OdxLinkRef):
     """
     This class represents the PRE-CONDITION-STATE-REF XML tag.
     """
-    value: Optional[str]
+    value: str | None = None
 
-    in_param_if_snref: Optional[str]
-    in_param_if_snpathref: Optional[str]
+    in_param_if_snref: str | None = None
+    in_param_if_snpathref: str | None = None
 
     @property
     def state(self) -> "State":
@@ -32,9 +33,8 @@ class PreConditionStateRef(OdxLinkRef):
 
     @staticmethod
     def from_et(  # type: ignore[override]
-            et_element: ElementTree.Element,
-            doc_frags: List[OdxDocFragment]) -> "PreConditionStateRef":
-        kwargs = dataclass_fields_asdict(OdxLinkRef.from_et(et_element, doc_frags))
+            et_element: ElementTree.Element, context: OdxDocContext) -> "PreConditionStateRef":
+        kwargs = dataclass_fields_asdict(OdxLinkRef.from_et(et_element, context))
 
         value = et_element.findtext("VALUE")
 
@@ -57,7 +57,7 @@ class PreConditionStateRef(OdxLinkRef):
             odxassert(self.in_param_if_snref is not None or self.in_param_if_snref is not None,
                       "If VALUE is specified, a parameter must be referenced")
 
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         return {}
 
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
@@ -66,7 +66,7 @@ class PreConditionStateRef(OdxLinkRef):
     def _resolve_snrefs(self, context: SnRefContext) -> None:
         pass
 
-    def applies(self, state_machine: "StateMachine", params: List[Parameter],
+    def applies(self, state_machine: "StateMachine", params: list[Parameter],
                 param_value_dict: ParameterValueDict) -> bool:
         """Given a state machine, evaluate whether the precondition is fulfilled or not
 

odxtools/progcode.py

@@ -1,24 +1,25 @@
 # SPDX-License-Identifier: MIT
-from dataclasses import dataclass
-from typing import Any, Dict, List, Optional, cast
+from dataclasses import dataclass, field
+from typing import Any, cast
 from xml.etree import ElementTree
 
 from .exceptions import odxraise, odxrequire
 from .library import Library
 from .nameditemlist import NamedItemList
-from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkId, OdxLinkRef
 from .snrefcontext import SnRefContext
 
 
-@dataclass
+@dataclass(kw_only=True)
 class ProgCode:
     """A reference to code that is executed by a single ECU job"""
     code_file: str
-    encryption: Optional[str]
+    encryption: str | None = None
     syntax: str
     revision: str
-    entrypoint: Optional[str]
-    library_refs: List[OdxLinkRef]
+    entrypoint: str | None = None
+    library_refs: list[OdxLinkRef] = field(default_factory=list)
 
     @property
     def code(self) -> bytes:
@@ -29,7 +30,7 @@ class ProgCode:
         return self._libraries
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "ProgCode":
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "ProgCode":
         code_file = odxrequire(et_element.findtext("CODE-FILE"))
         encryption = et_element.findtext("ENCRYPTION")
         syntax = odxrequire(et_element.findtext("SYNTAX"))
@@ -37,7 +38,7 @@ class ProgCode:
         entrypoint = et_element.findtext("ENTRYPOINT")
 
         library_refs = [
-            odxrequire(OdxLinkRef.from_et(el, doc_frags))
+            odxrequire(OdxLinkRef.from_et(el, context))
             for el in et_element.iterfind("LIBRARY-REFS/LIBRARY-REF")
         ]
 
@@ -50,7 +51,7 @@ class ProgCode:
             library_refs=library_refs,
         )
 
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         return {}
 
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:

odxtools/protstack.py

@@ -1,36 +1,37 @@
 # SPDX-License-Identifier: MIT
-from dataclasses import dataclass
-from typing import Any, Dict, List
+from dataclasses import dataclass, field
+from typing import Any
 from xml.etree import ElementTree
 
 from .comparamsubset import ComparamSubset
 from .element import IdentifiableElement
 from .exceptions import odxrequire
 from .nameditemlist import NamedItemList
-from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkId, OdxLinkRef
 from .snrefcontext import SnRefContext
 from .utils import dataclass_fields_asdict
 
 
-@dataclass
+@dataclass(kw_only=True)
 class ProtStack(IdentifiableElement):
     # mandatory in ODX 2.2, but non existent in ODX 2.0
     pdu_protocol_type: str
     physical_link_type: str
-    comparam_subset_refs: List[OdxLinkRef]
+    comparam_subset_refs: list[OdxLinkRef] = field(default_factory=list)
 
     @property
     def comparam_subsets(self) -> NamedItemList[ComparamSubset]:
         return self._comparam_subsets
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "ProtStack":
-        kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, doc_frags))
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "ProtStack":
+        kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, context))
 
         pdu_protocol_type = odxrequire(et_element.findtext("PDU-PROTOCOL-TYPE"))
         physical_link_type = odxrequire(et_element.findtext("PHYSICAL-LINK-TYPE"))
         comparam_subset_refs = [
-            OdxLinkRef.from_et(csr_element, doc_frags)
+            OdxLinkRef.from_et(csr_element, context)
             for csr_element in et_element.iterfind("COMPARAM-SUBSET-REFS/"
                                                    "COMPARAM-SUBSET-REF")
         ]
@@ -41,7 +42,7 @@ class ProtStack(IdentifiableElement):
             comparam_subset_refs=comparam_subset_refs,
             **kwargs)
 
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         result = {self.odx_id: self}
         return result
 

odxtools/relateddiagcommref.py

@@ -1,22 +1,21 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import List
 from xml.etree import ElementTree
 
 from .exceptions import odxrequire
-from .odxlink import OdxDocFragment, OdxLinkRef
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkRef
 from .utils import dataclass_fields_asdict
 
 
-@dataclass
+@dataclass(kw_only=True)
 class RelatedDiagCommRef(OdxLinkRef):
     relation_type: str
 
     @staticmethod
     def from_et(  # type: ignore[override]
-            et_element: ElementTree.Element,
-            doc_frags: List[OdxDocFragment]) -> "RelatedDiagCommRef":
-        kwargs = dataclass_fields_asdict(odxrequire(OdxLinkRef.from_et(et_element, doc_frags)))
+            et_element: ElementTree.Element, context: OdxDocContext) -> "RelatedDiagCommRef":
+        kwargs = dataclass_fields_asdict(odxrequire(OdxLinkRef.from_et(et_element, context)))
 
         relation_type = odxrequire(et_element.findtext("RELATION-TYPE"))
 

odxtools/relateddoc.py

@@ -1,32 +1,33 @@
 # 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 .description import Description
-from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkId
 from .snrefcontext import SnRefContext
 from .xdoc import XDoc
 
 
-@dataclass
+@dataclass(kw_only=True)
 class RelatedDoc:
-    xdoc: Optional[XDoc]
-    description: Optional[Description]
+    xdoc: XDoc | None = None
+    description: Description | None = None
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "RelatedDoc":
-        xdoc: Optional[XDoc] = None
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "RelatedDoc":
+        xdoc: XDoc | None = None
         if (xdoc_elem := et_element.find("XDOC")) is not None:
-            xdoc = XDoc.from_et(xdoc_elem, doc_frags)
-        description = Description.from_et(et_element.find("DESC"), doc_frags)
+            xdoc = XDoc.from_et(xdoc_elem, context)
+        description = Description.from_et(et_element.find("DESC"), context)
 
         return RelatedDoc(
             xdoc=xdoc,
             description=description,
         )
 
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         result = {}
 
         if self.xdoc: