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

odxtools/dynamicendmarkerfield.py

@@ -1,6 +1,7 @@
 # SPDX-License-Identifier: MIT
+from collections.abc import Sequence
 from dataclasses import dataclass
-from typing import Any, Dict, List, Sequence
+from typing import Any
 from xml.etree import ElementTree
 
 from typing_extensions import override
@@ -11,13 +12,14 @@ from .dynenddopref import DynEndDopRef
 from .encodestate import EncodeState
 from .exceptions import DecodeError, EncodeError, odxassert, odxraise, odxrequire
 from .field import Field
-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
 
 
-@dataclass
+@dataclass(kw_only=True)
 class DynamicEndmarkerField(Field):
     """Array of a structure with variable length determined by a termination sequence"""
 
@@ -32,18 +34,17 @@ class DynamicEndmarkerField(Field):
         return self._termination_value
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element,
-                doc_frags: List[OdxDocFragment]) -> "DynamicEndmarkerField":
-        kwargs = dataclass_fields_asdict(Field.from_et(et_element, doc_frags))
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "DynamicEndmarkerField":
+        kwargs = dataclass_fields_asdict(Field.from_et(et_element, context))
 
         # ODX 2.0 uses DATA-OBJECT-PROP-REF
         # ODX 2.2 uses DYN-END-DOP-REF
         dop_ref = et_element.find("DYN-END-DOP-REF") or et_element.find("DATA-OBJECT-PROP-REF")
-        dyn_end_dop_ref = DynEndDopRef.from_et(odxrequire(dop_ref), doc_frags)
+        dyn_end_dop_ref = DynEndDopRef.from_et(odxrequire(dop_ref), context)
 
         return DynamicEndmarkerField(dyn_end_dop_ref=dyn_end_dop_ref, **kwargs)
 
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         odxlinks = super()._build_odxlinks()
         return odxlinks
 
@@ -102,7 +103,7 @@ class DynamicEndmarkerField(Field):
         orig_origin = decode_state.origin_byte_position
         decode_state.origin_byte_position = decode_state.cursor_byte_position
 
-        result: List[ParameterValue] = []
+        result: list[ParameterValue] = []
         while True:
             # check if we're at the end of the PDU
             if decode_state.cursor_byte_position == len(decode_state.coded_message):

odxtools/dynamiclengthfield.py

@@ -1,6 +1,7 @@
 # SPDX-License-Identifier: MIT
+from collections.abc import Sequence
 from dataclasses import dataclass
-from typing import Any, Dict, List, Sequence
+from typing import Any
 from xml.etree import ElementTree
 
 from typing_extensions import override
@@ -10,33 +11,33 @@ from .determinenumberofitems import DetermineNumberOfItems
 from .encodestate import EncodeState
 from .exceptions import DecodeError, EncodeError, odxassert, odxraise, odxrequire
 from .field import Field
-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
 
 
-@dataclass
+@dataclass(kw_only=True)
 class DynamicLengthField(Field):
     """Array of structure with length field"""
     offset: int
     determine_number_of_items: DetermineNumberOfItems
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element,
-                doc_frags: List[OdxDocFragment]) -> "DynamicLengthField":
-        kwargs = dataclass_fields_asdict(Field.from_et(et_element, doc_frags))
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "DynamicLengthField":
+        kwargs = dataclass_fields_asdict(Field.from_et(et_element, context))
 
         offset = int(odxrequire(et_element.findtext('OFFSET')))
         determine_number_of_items = DetermineNumberOfItems.from_et(
             odxrequire(et_element.find('DETERMINE-NUMBER-OF-ITEMS')),
-            doc_frags,
+            context,
         )
 
         return DynamicLengthField(
             offset=offset, determine_number_of_items=determine_number_of_items, **kwargs)
 
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         odxlinks = super()._build_odxlinks()
         odxlinks.update(self.determine_number_of_items._build_odxlinks())
         return odxlinks
@@ -106,7 +107,7 @@ class DynamicLengthField(Field):
         decode_state.cursor_bit_position = det_num_items.bit_position or 0
 
         n = det_num_items.dop.decode_from_pdu(decode_state)
-        result: List[ParameterValue] = []
+        result: list[ParameterValue] = []
 
         if not isinstance(n, int):
             odxraise(f"Number of items specified by a dynamic length field {self.short_name} "

odxtools/dyndefinedspec.py

@@ -1,28 +1,28 @@
 # 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 .dyniddefmodeinfo import DynIdDefModeInfo
-from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkId
 from .snrefcontext import SnRefContext
 
 
-@dataclass
+@dataclass(kw_only=True)
 class DynDefinedSpec:
-    dyn_id_def_mode_infos: List[DynIdDefModeInfo]
+    dyn_id_def_mode_infos: list[DynIdDefModeInfo] = field(default_factory=list)
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element,
-                doc_frags: List[OdxDocFragment]) -> "DynDefinedSpec":
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "DynDefinedSpec":
         dyn_id_def_mode_infos = [
-            DynIdDefModeInfo.from_et(x, doc_frags)
+            DynIdDefModeInfo.from_et(x, context)
             for x in et_element.iterfind("DYN-ID-DEF-MODE-INFOS/DYN-ID-DEF-MODE-INFO")
         ]
         return DynDefinedSpec(dyn_id_def_mode_infos=dyn_id_def_mode_infos)
 
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
-        result: Dict[OdxLinkId, Any] = {}
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
+        result: dict[OdxLinkId, Any] = {}
 
         for didmi in self.dyn_id_def_mode_infos:
             result.update(didmi._build_odxlinks())

odxtools/dynenddopref.py

@@ -1,37 +1,37 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import List, Optional, overload
+from typing import Optional, overload
 from xml.etree import ElementTree
 
 from .exceptions import odxraise, 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 DynEndDopRef(OdxLinkRef):
     termination_value_raw: str
 
     @staticmethod
     @overload
-    def from_et(et_element: None, source_doc_frags: List[OdxDocFragment]) -> None:
+    def from_et(et_element: None, context: OdxDocContext) -> None:
         ...
 
     @staticmethod
     @overload
-    def from_et(et_element: ElementTree.Element,
-                source_doc_frags: List[OdxDocFragment]) -> "DynEndDopRef":
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "DynEndDopRef":
         ...
 
     @staticmethod
-    def from_et(et_element: Optional[ElementTree.Element],
-                source_doc_frags: List[OdxDocFragment]) -> Optional["DynEndDopRef"]:
+    def from_et(et_element: ElementTree.Element | None,
+                context: OdxDocContext) -> Optional["DynEndDopRef"]:
 
         if et_element is None:
             odxraise("Mandatory DYN-END-DOP-REF tag is missing")
             return None
 
-        kwargs = dataclass_fields_asdict(OdxLinkRef.from_et(et_element, source_doc_frags))
+        kwargs = dataclass_fields_asdict(OdxLinkRef.from_et(et_element, context))
 
         termination_value_raw = odxrequire(et_element.findtext("TERMINATION-VALUE"))
 

odxtools/dyniddefmodeinfo.py

@@ -1,32 +1,33 @@
 # SPDX-License-Identifier: MIT
-from dataclasses import dataclass
-from typing import Any, Dict, List, Optional, Union
+from dataclasses import dataclass, field
+from typing import Any
 from xml.etree import ElementTree
 
 from .diagclasstype import DiagClassType
 from .diagcomm import DiagComm
 from .exceptions import odxassert, odxraise, odxrequire
 from .nameditemlist import NamedItemList
-from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef, resolve_snref
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkId, OdxLinkRef, resolve_snref
 from .snrefcontext import SnRefContext
 from .table import Table
 
 
-@dataclass
+@dataclass(kw_only=True)
 class DynIdDefModeInfo:
     def_mode: str
 
-    clear_dyn_def_message_ref: Optional[OdxLinkRef]
-    clear_dyn_def_message_snref: Optional[str]
+    clear_dyn_def_message_ref: OdxLinkRef | None = None
+    clear_dyn_def_message_snref: str | None = None
 
-    read_dyn_def_message_ref: Optional[OdxLinkRef]
-    read_dyn_def_message_snref: Optional[str]
+    read_dyn_def_message_ref: OdxLinkRef | None = None
+    read_dyn_def_message_snref: str | None = None
 
-    dyn_def_message_ref: Optional[OdxLinkRef]
-    dyn_def_message_snref: Optional[str]
+    dyn_def_message_ref: OdxLinkRef | None = None
+    dyn_def_message_snref: str | None = None
 
-    supported_dyn_ids: List[bytes]
-    selection_table_refs: List[Union[OdxLinkRef, str]]
+    supported_dyn_ids: list[bytes] = field(default_factory=list)
+    selection_table_refs: list[OdxLinkRef | str] = field(default_factory=list)
 
     @property
     def clear_dyn_def_message(self) -> DiagComm:
@@ -45,23 +46,22 @@ class DynIdDefModeInfo:
         return self._selection_tables
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element,
-                doc_frags: List[OdxDocFragment]) -> "DynIdDefModeInfo":
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "DynIdDefModeInfo":
         def_mode = odxrequire(et_element.findtext("DEF-MODE"))
 
         clear_dyn_def_message_ref = OdxLinkRef.from_et(
-            et_element.find("CLEAR-DYN-DEF-MESSAGE-REF"), doc_frags)
+            et_element.find("CLEAR-DYN-DEF-MESSAGE-REF"), context)
         clear_dyn_def_message_snref = None
         if (snref_elem := et_element.find("CLEAR-DYN-DEF-MESSAGE-SNREF")) is not None:
             clear_dyn_def_message_snref = odxrequire(snref_elem.attrib.get("SHORT-NAME"))
 
         read_dyn_def_message_ref = OdxLinkRef.from_et(
-            et_element.find("READ-DYN-DEF-MESSAGE-REF"), doc_frags)
+            et_element.find("READ-DYN-DEF-MESSAGE-REF"), context)
         read_dyn_def_message_snref = None
         if (snref_elem := et_element.find("READ-DYN-DEF-MESSAGE-SNREF")) is not None:
             read_dyn_def_message_snref = odxrequire(snref_elem.attrib.get("SHORT-NAME"))
 
-        dyn_def_message_ref = OdxLinkRef.from_et(et_element.find("DYN-DEF-MESSAGE-REF"), doc_frags)
+        dyn_def_message_ref = OdxLinkRef.from_et(et_element.find("DYN-DEF-MESSAGE-REF"), context)
         dyn_def_message_snref = None
         if (snref_elem := et_element.find("DYN-DEF-MESSAGE-SNREF")) is not None:
             dyn_def_message_snref = odxrequire(snref_elem.attrib.get("SHORT-NAME"))
@@ -71,11 +71,11 @@ class DynIdDefModeInfo:
             for x in et_element.iterfind("SUPPORTED-DYN-IDS/SUPPORTED-DYN-ID")
         ]
 
-        selection_table_refs: List[Union[OdxLinkRef, str]] = []
+        selection_table_refs: list[OdxLinkRef | str] = []
         if (st_elems := et_element.find("SELECTION-TABLE-REFS")) is not None:
             for st_elem in st_elems:
                 if st_elem.tag == "SELECTION-TABLE-REF":
-                    selection_table_refs.append(OdxLinkRef.from_et(st_elem, doc_frags))
+                    selection_table_refs.append(OdxLinkRef.from_et(st_elem, context))
                 elif st_elem.tag == "SELECTION-TABLE-SNREF":
                     selection_table_refs.append(odxrequire(st_elem.get("SHORT-NAME")))
                 else:
@@ -104,8 +104,8 @@ class DynIdDefModeInfo:
         odxassert(self.dyn_def_message_ref is not None or self.dyn_def_message_snref is not None,
                   "A DYN-DEF-MESSAGE must be specified")
 
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
-        result: Dict[OdxLinkId, Any] = {}
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
+        result: dict[OdxLinkId, Any] = {}
 
         return result
 

odxtools/ecuvariantpattern.py

@@ -1,6 +1,5 @@
 # SPDX-License-Identifier: MIT
-from dataclasses import dataclass
-from typing import List, Union
+from dataclasses import dataclass, field
 from xml.etree import ElementTree
 
 from typing_extensions import override
@@ -8,28 +7,27 @@ from typing_extensions import override
 from .exceptions import odxassert
 from .matchingbasevariantparameter import MatchingBaseVariantParameter
 from .matchingparameter import MatchingParameter
-from .odxlink import OdxDocFragment
+from .odxdoccontext import OdxDocContext
 from .variantpattern import VariantPattern
 
 
-@dataclass
+@dataclass(kw_only=True)
 class EcuVariantPattern(VariantPattern):
     """ECU variant patterns are variant patterns used to identify the
     concrete variant of an ECU.
     """
-    matching_parameters: List[MatchingParameter]
+    matching_parameters: list[MatchingParameter] = field(default_factory=list)
 
     @override
-    def get_matching_parameters(
-            self) -> Union[List[MatchingParameter], List[MatchingBaseVariantParameter]]:
+    def get_matching_parameters(self
+                               ) -> list[MatchingParameter] | list[MatchingBaseVariantParameter]:
         return self.matching_parameters
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element,
-                doc_frags: List[OdxDocFragment]) -> "EcuVariantPattern":
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "EcuVariantPattern":
 
         matching_parameters = [
-            MatchingParameter.from_et(mp_el, doc_frags)
+            MatchingParameter.from_et(mp_el, context)
             for mp_el in et_element.iterfind("MATCHING-PARAMETERS/"
                                              "MATCHING-PARAMETER")
         ]

odxtools/element.py

@@ -1,41 +1,40 @@
 from dataclasses import dataclass
-from typing import List, Optional
 from xml.etree import ElementTree
 
 from .description import Description
 from .exceptions import odxrequire
-from .odxlink import OdxDocFragment, OdxLinkId
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkId
 from .utils import dataclass_fields_asdict
 
 
-@dataclass
+@dataclass(kw_only=True)
 class NamedElement:
     short_name: str
-    long_name: Optional[str]
-    description: Optional[Description]
+    long_name: str | None = None
+    description: Description | None = None
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "NamedElement":
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "NamedElement":
 
         return NamedElement(
             short_name=odxrequire(et_element.findtext("SHORT-NAME")),
             long_name=et_element.findtext("LONG-NAME"),
-            description=Description.from_et(et_element.find("DESC"), doc_frags),
+            description=Description.from_et(et_element.find("DESC"), context),
         )
 
 
-@dataclass
+@dataclass(kw_only=True)
 class IdentifiableElement(NamedElement):
     odx_id: OdxLinkId
-    oid: Optional[str]
+    oid: str | None = None
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element,
-                doc_frags: List[OdxDocFragment]) -> "IdentifiableElement":
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "IdentifiableElement":
 
-        kwargs = dataclass_fields_asdict(NamedElement.from_et(et_element, doc_frags))
+        kwargs = dataclass_fields_asdict(NamedElement.from_et(et_element, context))
 
-        odx_id = odxrequire(OdxLinkId.from_et(et_element, doc_frags))
+        odx_id = odxrequire(OdxLinkId.from_et(et_element, context))
         oid = et_element.get("OID")
 
         return IdentifiableElement(**kwargs, odx_id=odx_id, oid=oid)

odxtools/encodestate.py

@@ -1,7 +1,7 @@
 # SPDX-License-Identifier: MIT
 import warnings
 from dataclasses import dataclass, field
-from typing import TYPE_CHECKING, Dict, List, Optional, Tuple
+from typing import TYPE_CHECKING
 
 from .encoding import Encoding, get_string_encoding
 from .exceptions import EncodeError, OdxWarning, odxassert, odxraise
@@ -41,20 +41,20 @@ class EncodeState:
     cursor_bit_position: int = 0
 
     #: If encoding a response: request that triggered the response
-    triggering_request: Optional[bytes] = None
+    triggering_request: bytes | None = None
 
     #: Mapping from the short name of a length-key parameter to bit
     #: lengths (specified by LengthKeyParameter)
-    length_keys: Dict[str, int] = field(default_factory=dict)
+    length_keys: dict[str, int] = field(default_factory=dict)
 
     #: Mapping from the short name of a table-key parameter to the
     #: short name of the corresponding row of the table (specified by
     #: TableKeyParameter)
-    table_keys: Dict[str, str] = field(default_factory=dict)
+    table_keys: dict[str, str] = field(default_factory=dict)
 
     #: The cursor position where a given length- or table key is located
     #: in the PDU
-    key_pos: Dict[str, int] = field(default_factory=dict)
+    key_pos: dict[str, int] = field(default_factory=dict)
 
     #: Flag whether we are currently the last parameter of the PDU
     #: (needed for MinMaxLengthType, EndOfPduField, etc.)
@@ -63,7 +63,7 @@ class EncodeState:
     #: list of parameters that have been encoded so far. The journal
     #: is used by some types of parameters which depend on the values of
     #: other parameters; e.g., environment data description parameters
-    journal: List[Tuple["Parameter", Optional[ParameterValue]]] = field(default_factory=list)
+    journal: list[tuple["Parameter", ParameterValue | None]] = field(default_factory=list)
 
     #: If this is True, specifying unknown parameters for encoding
     #: will raise an OdxError exception in strict mode.
@@ -87,9 +87,9 @@ class EncodeState:
         internal_value: AtomicOdxType,
         bit_length: int,
         base_data_type: DataType,
-        base_type_encoding: Optional[Encoding],
+        base_type_encoding: Encoding | None,
         is_highlow_byte_order: bool,
-        used_mask: Optional[bytes],
+        used_mask: bytes | None,
     ) -> None:
         """Convert the internal_value to bytes and emplace this into the PDU"""
 
@@ -220,7 +220,7 @@ class EncodeState:
                 odxraise(f"Illegal bit length for a float64 object ({bit_length})")
                 bit_length = 64
 
-            raw_value = float(internal_value)
+            raw_value = float(internal_value)  # type: ignore[arg-type]
 
         # If the bit length is zero, encode an empty value
         if bit_length == 0:
@@ -260,8 +260,8 @@ class EncodeState:
 
     def emplace_bytes(self,
                       new_data: bytes,
-                      obj_name: Optional[str] = None,
-                      obj_used_mask: Optional[bytes] = None) -> None:
+                      obj_name: str | None = None,
+                      obj_used_mask: bytes | None = None) -> None:
         if self.cursor_bit_position != 0:
             odxraise("EncodeState.emplace_bytes can only be called "
                      "for a bit position of 0!", RuntimeError)

odxtools/encoding.py

@@ -1,6 +1,5 @@
 # SPDX-License-Identifier: MIT
 from enum import Enum
-from typing import Optional
 
 from .exceptions import odxraise
 from .odxtypes import DataType
@@ -23,8 +22,8 @@ class Encoding(Enum):
     NONE = "NONE"
 
 
-def get_string_encoding(base_data_type: DataType, base_type_encoding: Optional[Encoding],
-                        is_highlow_byte_order: bool) -> Optional[str]:
+def get_string_encoding(base_data_type: DataType, base_type_encoding: Encoding | None,
+                        is_highlow_byte_order: bool) -> str | None:
     """If the encoding is for a string, return the value for
     `str.encode()`/`str.decode()` to convert the string object
     to/from a byte array

odxtools/endofpdufield.py

@@ -1,6 +1,6 @@
 # SPDX-License-Identifier: MIT
+from collections.abc import Sequence
 from dataclasses import dataclass
-from typing import List, Optional, Sequence
 from xml.etree import ElementTree
 
 from typing_extensions import override
@@ -9,21 +9,20 @@ from .decodestate import DecodeState
 from .encodestate import EncodeState
 from .exceptions import EncodeError, odxassert, odxraise
 from .field import Field
-from .odxlink import OdxDocFragment
+from .odxdoccontext import OdxDocContext
 from .odxtypes import ParameterValue
 from .utils import dataclass_fields_asdict
 
 
-@dataclass
+@dataclass(kw_only=True)
 class EndOfPduField(Field):
     """End of PDU fields are structures that are repeated until the end of the PDU"""
-    max_number_of_items: Optional[int]
-    min_number_of_items: Optional[int]
+    max_number_of_items: int | None = None
+    min_number_of_items: int | None = None
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element,
-                doc_frags: List[OdxDocFragment]) -> "EndOfPduField":
-        kwargs = dataclass_fields_asdict(Field.from_et(et_element, doc_frags))
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "EndOfPduField":
+        kwargs = dataclass_fields_asdict(Field.from_et(et_element, context))
 
         if (max_n_str := et_element.findtext("MAX-NUMBER-OF-ITEMS")) is not None:
             max_number_of_items = int(max_n_str)
@@ -40,7 +39,7 @@ class EndOfPduField(Field):
             **kwargs)
 
     @override
-    def encode_into_pdu(self, physical_value: Optional[ParameterValue],
+    def encode_into_pdu(self, physical_value: ParameterValue | None,
                         encode_state: EncodeState) -> None:
         odxassert(not encode_state.cursor_bit_position,
                   "No bit position can be specified for end-of-pdu fields!")
@@ -72,7 +71,7 @@ class EndOfPduField(Field):
         orig_origin = decode_state.origin_byte_position
         decode_state.origin_byte_position = decode_state.cursor_byte_position
 
-        result: List[ParameterValue] = []
+        result: list[ParameterValue] = []
         while decode_state.cursor_byte_position < len(decode_state.coded_message):
             # ATTENTION: the ODX specification is very misleading
             # here: it says that the item is repeated until the end of

odxtools/envdataconnector.py

@@ -1,18 +1,19 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import Any, Dict, List
+from typing import Any
 from xml.etree import ElementTree
 
 from .element import NamedElement
 from .environmentdata import EnvironmentData
 from .environmentdatadescription import EnvironmentDataDescription
 from .exceptions import odxrequire
-from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef, resolve_snref
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkId, OdxLinkRef, resolve_snref
 from .snrefcontext import SnRefContext
 from .utils import dataclass_fields_asdict
 
 
-@dataclass
+@dataclass(kw_only=True)
 class EnvDataConnector(NamedElement):
     env_data_desc_ref: OdxLinkRef
     env_data_snref: str
@@ -26,19 +27,18 @@ class EnvDataConnector(NamedElement):
         return self._env_data
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element,
-                doc_frags: List[OdxDocFragment]) -> "EnvDataConnector":
-        kwargs = dataclass_fields_asdict(NamedElement.from_et(et_element, doc_frags))
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "EnvDataConnector":
+        kwargs = dataclass_fields_asdict(NamedElement.from_et(et_element, context))
 
         env_data_desc_ref = odxrequire(
-            OdxLinkRef.from_et(et_element.find("ENV-DATA-DESC-REF"), doc_frags))
+            OdxLinkRef.from_et(et_element.find("ENV-DATA-DESC-REF"), context))
         env_data_snref_el = odxrequire(et_element.find("ENV-DATA-SNREF"))
         env_data_snref = odxrequire(env_data_snref_el.get("SHORT-NAME"))
 
         return EnvDataConnector(
             env_data_desc_ref=env_data_desc_ref, env_data_snref=env_data_snref, **kwargs)
 
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         return {}
 
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:

odxtools/environmentdata.py

@@ -1,15 +1,14 @@
 # SPDX-License-Identifier: MIT
-from dataclasses import dataclass
-from typing import List, Optional
+from dataclasses import dataclass, field
 from xml.etree import ElementTree
 
 from .basicstructure import BasicStructure
 from .exceptions import odxrequire
-from .odxlink import OdxDocFragment
+from .odxdoccontext import OdxDocContext
 from .utils import dataclass_fields_asdict
 
 
-@dataclass
+@dataclass(kw_only=True)
 class EnvironmentData(BasicStructure):
     """This class represents Environment Data that describes the
     circumstances in which the error occurred.
@@ -20,14 +19,13 @@ class EnvironmentData(BasicStructure):
     sense, it is quite similar to NRC-CONST parameters.)
     """
 
-    all_value: Optional[bool]
-    dtc_values: List[int]
+    all_value: bool | None = None
+    dtc_values: list[int] = field(default_factory=list)
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element,
-                doc_frags: List[OdxDocFragment]) -> "EnvironmentData":
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "EnvironmentData":
         """Reads Environment Data from Diag Layer."""
-        kwargs = dataclass_fields_asdict(BasicStructure.from_et(et_element, doc_frags))
+        kwargs = dataclass_fields_asdict(BasicStructure.from_et(et_element, context))
 
         all_value_elem = et_element.find("ALL-VALUE")
         all_value = None if all_value_elem is None else True