odxtools 9.6.1__py3-none-any.whl → 10.0.0__py3-none-any.whl

odxtools/dyniddefmodeinfo.py

@@ -0,0 +1,161 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass
+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 .snrefcontext import SnRefContext
+from .table import Table
+
+
+@dataclass
+class DynIdDefModeInfo:
+    def_mode: str
+
+    clear_dyn_def_message_ref: OdxLinkRef | None
+    clear_dyn_def_message_snref: str | None
+
+    read_dyn_def_message_ref: OdxLinkRef | None
+    read_dyn_def_message_snref: str | None
+
+    dyn_def_message_ref: OdxLinkRef | None
+    dyn_def_message_snref: str | None
+
+    supported_dyn_ids: list[bytes]
+    selection_table_refs: list[OdxLinkRef | str]
+
+    @property
+    def clear_dyn_def_message(self) -> DiagComm:
+        return self._clear_dyn_def_message
+
+    @property
+    def read_dyn_def_message(self) -> DiagComm:
+        return self._read_dyn_def_message
+
+    @property
+    def dyn_def_message(self) -> DiagComm:
+        return self._dyn_def_message
+
+    @property
+    def selection_tables(self) -> NamedItemList[Table]:
+        return self._selection_tables
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element,
+                doc_frags: list[OdxDocFragment]) -> "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)
+        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)
+        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_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"))
+
+        supported_dyn_ids = [
+            bytes.fromhex(odxrequire(x.text))
+            for x in et_element.iterfind("SUPPORTED-DYN-IDS/SUPPORTED-DYN-ID")
+        ]
+
+        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))
+                elif st_elem.tag == "SELECTION-TABLE-SNREF":
+                    selection_table_refs.append(odxrequire(st_elem.get("SHORT-NAME")))
+                else:
+                    odxraise()
+
+        return DynIdDefModeInfo(
+            def_mode=def_mode,
+            clear_dyn_def_message_ref=clear_dyn_def_message_ref,
+            clear_dyn_def_message_snref=clear_dyn_def_message_snref,
+            read_dyn_def_message_ref=read_dyn_def_message_ref,
+            read_dyn_def_message_snref=read_dyn_def_message_snref,
+            dyn_def_message_ref=dyn_def_message_ref,
+            dyn_def_message_snref=dyn_def_message_snref,
+            supported_dyn_ids=supported_dyn_ids,
+            selection_table_refs=selection_table_refs,
+        )
+
+    def __post_init__(self) -> None:
+        odxassert(
+            self.clear_dyn_def_message_ref is not None or
+            self.clear_dyn_def_message_snref is not None,
+            "A CLEAR-DYN-DEF-MESSAGE must be specified")
+        odxassert(
+            self.read_dyn_def_message_ref is not None or
+            self.read_dyn_def_message_snref is not None, "A READ-DYN-DEF-MESSAGE must be specified")
+        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] = {}
+
+        return result
+
+    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
+        if self.clear_dyn_def_message_ref is not None:
+            self._clear_dyn_def_message = odxlinks.resolve(self.clear_dyn_def_message_ref, DiagComm)
+
+        if self.read_dyn_def_message_ref is not None:
+            self._read_dyn_def_message = odxlinks.resolve(self.read_dyn_def_message_ref, DiagComm)
+
+        if self.dyn_def_message_ref is not None:
+            self._dyn_def_message = odxlinks.resolve(self.dyn_def_message_ref, DiagComm)
+
+        # resolve the selection tables that are referenced via ODXLINK
+        self._selection_tables = NamedItemList[Table]()
+        for x in self.selection_table_refs:
+            if isinstance(x, OdxLinkRef):
+                self._selection_tables.append(odxlinks.resolve(x, Table))
+
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
+        diag_layer = odxrequire(context.diag_layer)
+
+        if self.clear_dyn_def_message_snref is not None:
+            self._clear_dyn_def_message = resolve_snref(self.clear_dyn_def_message_snref,
+                                                        diag_layer.diag_comms, DiagComm)
+
+        if self.read_dyn_def_message_snref is not None:
+            self._read_dyn_def_message = resolve_snref(self.read_dyn_def_message_snref,
+                                                       diag_layer.diag_comms, DiagComm)
+
+        if self.dyn_def_message_snref is not None:
+            self._dyn_def_message = resolve_snref(self.dyn_def_message_snref, diag_layer.diag_comms,
+                                                  DiagComm)
+
+        if self._clear_dyn_def_message.diagnostic_class != DiagClassType.CLEAR_DYN_DEF_MESSAGE:
+            odxraise(
+                f"Diagnostic communication object of wrong type referenced: "
+                f"({odxrequire(self._clear_dyn_def_message.diagnostic_class).value} instead of "
+                f"CLEAR-DYN-DEF-MESSAGE)")
+        if self._read_dyn_def_message.diagnostic_class != DiagClassType.READ_DYN_DEFINED_MESSAGE:
+            odxraise(f"Diagnostic communication object of wrong type referenced: "
+                     f"({odxrequire(self._read_dyn_def_message.diagnostic_class).value} instead of "
+                     f"READ-DYN-DEFINED-MESSAGE)")
+        if self._dyn_def_message.diagnostic_class != DiagClassType.DYN_DEF_MESSAGE:
+            odxraise(f"Diagnostic communication object of wrong type referenced: "
+                     f"({odxrequire(self._dyn_def_message.diagnostic_class).value} instead of "
+                     f"DYN-DEF-MESSAGE)")
+
+        # resolve the remaining selection tables that are referenced via SNREF
+        ddd_spec = odxrequire(diag_layer.diag_data_dictionary_spec)
+        for i, x in enumerate(self.selection_table_refs):
+            if isinstance(x, str):
+                self._selection_tables.insert(i, resolve_snref(x, ddd_spec.tables, Table))

odxtools/ecuvariantpattern.py

@@ -1,6 +1,5 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import List, Union
 from xml.etree import ElementTree
 
 from typing_extensions import override
@@ -17,16 +16,16 @@ 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]
 
     @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":
+                doc_frags: list[OdxDocFragment]) -> "EcuVariantPattern":
 
         matching_parameters = [
             MatchingParameter.from_et(mp_el, doc_frags)

odxtools/element.py

@@ -1,5 +1,4 @@
 from dataclasses import dataclass
-from typing import List, Optional
 from xml.etree import ElementTree
 
 from .description import Description
@@ -11,11 +10,11 @@ from .utils import dataclass_fields_asdict
 @dataclass
 class NamedElement:
     short_name: str
-    long_name: Optional[str]
-    description: Optional[Description]
+    long_name: str | None
+    description: Description | None
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "NamedElement":
+    def from_et(et_element: ElementTree.Element, doc_frags: list[OdxDocFragment]) -> "NamedElement":
 
         return NamedElement(
             short_name=odxrequire(et_element.findtext("SHORT-NAME")),
@@ -27,11 +26,11 @@ class NamedElement:
 @dataclass
 class IdentifiableElement(NamedElement):
     odx_id: OdxLinkId
-    oid: Optional[str]
+    oid: str | None
 
     @staticmethod
     def from_et(et_element: ElementTree.Element,
-                doc_frags: List[OdxDocFragment]) -> "IdentifiableElement":
+                doc_frags: list[OdxDocFragment]) -> "IdentifiableElement":
 
         kwargs = dataclass_fields_asdict(NamedElement.from_et(et_element, doc_frags))
 

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
@@ -17,12 +17,12 @@ from .utils import dataclass_fields_asdict
 @dataclass
 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
+    min_number_of_items: int | None
 
     @staticmethod
     def from_et(et_element: ElementTree.Element,
-                doc_frags: List[OdxDocFragment]) -> "EndOfPduField":
+                doc_frags: list[OdxDocFragment]) -> "EndOfPduField":
         kwargs = dataclass_fields_asdict(Field.from_et(et_element, doc_frags))
 
         if (max_n_str := et_element.findtext("MAX-NUMBER-OF-ITEMS")) is not None:
@@ -40,7 +40,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 +72,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

@@ -0,0 +1,49 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass
+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 .snrefcontext import SnRefContext
+from .utils import dataclass_fields_asdict
+
+
+@dataclass
+class EnvDataConnector(NamedElement):
+    env_data_desc_ref: OdxLinkRef
+    env_data_snref: str
+
+    @property
+    def env_data_desc(self) -> EnvironmentDataDescription:
+        return self._env_data_desc
+
+    @property
+    def env_data(self) -> EnvironmentData:
+        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))
+
+        env_data_desc_ref = odxrequire(
+            OdxLinkRef.from_et(et_element.find("ENV-DATA-DESC-REF"), doc_frags))
+        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]:
+        return {}
+
+    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
+        self._env_data_desc = odxlinks.resolve(self.env_data_desc_ref, EnvironmentDataDescription)
+
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
+        self._env_data = resolve_snref(self.env_data_snref, self._env_data_desc.env_datas,
+                                       EnvironmentData)

odxtools/environmentdata.py

@@ -1,6 +1,5 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import List, Optional
 from xml.etree import ElementTree
 
 from .basicstructure import BasicStructure
@@ -20,12 +19,12 @@ class EnvironmentData(BasicStructure):
     sense, it is quite similar to NRC-CONST parameters.)
     """
 
-    all_value: Optional[bool]
-    dtc_values: List[int]
+    all_value: bool | None
+    dtc_values: list[int]
 
     @staticmethod
     def from_et(et_element: ElementTree.Element,
-                doc_frags: List[OdxDocFragment]) -> "EnvironmentData":
+                doc_frags: list[OdxDocFragment]) -> "EnvironmentData":
         """Reads Environment Data from Diag Layer."""
         kwargs = dataclass_fields_asdict(BasicStructure.from_et(et_element, doc_frags))
 

odxtools/environmentdatadescription.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
@@ -35,18 +35,18 @@ class EnvironmentDataDescription(ComplexDop):
 
     """
 
-    param_snref: Optional[str]
-    param_snpathref: Optional[str]
+    param_snref: str | None
+    param_snpathref: str | None
 
     # in ODX 2.0.0, ENV-DATAS seems to be a mandatory
     # sub-element of ENV-DATA-DESC, in ODX 2.2 it is not
     # present
     env_datas: NamedItemList[EnvironmentData]
-    env_data_refs: List[OdxLinkRef]
+    env_data_refs: list[OdxLinkRef]
 
     @staticmethod
     def from_et(et_element: ElementTree.Element,
-                doc_frags: List[OdxDocFragment]) -> "EnvironmentDataDescription":
+                doc_frags: list[OdxDocFragment]) -> "EnvironmentDataDescription":
         """Reads Environment Data Description from Diag Layer."""
         kwargs = dataclass_fields_asdict(ComplexDop.from_et(et_element, doc_frags))
 
@@ -78,7 +78,7 @@ class EnvironmentDataDescription(ComplexDop):
             env_data_refs=env_data_refs,
             **kwargs)
 
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         odxlinks = {self.odx_id: self}
 
         if not self.env_data_refs:
@@ -105,7 +105,7 @@ class EnvironmentDataDescription(ComplexDop):
                 ed._resolve_snrefs(context)
 
     @override
-    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 bytes and emplace them into a PDU.
         """
@@ -118,7 +118,7 @@ class EnvironmentDataDescription(ComplexDop):
                      "descriptions via SNPATHREF is not supported yet")
             return None
 
-        numerical_dtc_value: Optional[ParameterValue] = None
+        numerical_dtc_value: ParameterValue | None = None
         for prev_param, prev_param_value in reversed(encode_state.journal):
             if prev_param.short_name == self.param_snref:
                 numerical_dtc_value = self._get_numerical_dtc_from_parameter(
@@ -165,7 +165,7 @@ class EnvironmentDataDescription(ComplexDop):
                      "descriptions via SNPATHREF is not supported yet")
             return None
 
-        numerical_dtc_value: Optional[ParameterValue] = None
+        numerical_dtc_value: ParameterValue | None = None
         for prev_param, prev_param_value in reversed(decode_state.journal):
             if prev_param.short_name == self.param_snref:
                 numerical_dtc_value = self._get_numerical_dtc_from_parameter(
@@ -204,10 +204,10 @@ class EnvironmentDataDescription(ComplexDop):
         return result
 
     def _get_numerical_dtc_from_parameter(self, param: Parameter,
-                                          param_value: Optional[ParameterValue]) -> int:
+                                          param_value: ParameterValue | None) -> int:
         if isinstance(param, ParameterWithDOP):
             dop = param.dop
-            if not isinstance(dop, (DataObjectProperty, DtcDop)):
+            if not isinstance(dop, DataObjectProperty | DtcDop):
                 odxraise(f"The DOP of the parameter referenced by environment data descriptions "
                          f"must use either be DataObjectProperty or a DtcDop (encountered "
                          f"{type(param).__name__} for parameter '{param.short_name}' "

odxtools/exceptions.py

@@ -1,5 +1,5 @@
 # SPDX-License-Identifier: MIT
-from typing import TYPE_CHECKING, NoReturn, Optional, Type, TypeVar
+from typing import TYPE_CHECKING, NoReturn, TypeVar
 
 from .globals import logger
 
@@ -37,7 +37,7 @@ class OdxWarning(Warning):
 strict_mode = True
 
 
-def odxraise(message: Optional[str] = None, error_type: Type[Exception] = OdxError) -> NoReturn:
+def odxraise(message: str | None = None, error_type: type[Exception] = OdxError) -> NoReturn:
     """
     Raise an exception but only if in strict mode.
 
@@ -53,8 +53,8 @@ def odxraise(message: Optional[str] = None, error_type: Type[Exception] = OdxErr
 
 
 def odxassert(condition: bool,
-              message: Optional[str] = None,
-              error_type: Type[Exception] = OdxError) -> None:
+              message: str | None = None,
+              error_type: type[Exception] = OdxError) -> None:
     """
     This method works similar as the build-in `assert` statement
 
@@ -72,7 +72,7 @@ def odxassert(condition: bool,
 T = TypeVar("T")
 
 
-def odxrequire(obj: Optional[T], message: Optional[str] = None) -> T:
+def odxrequire(obj: T | None, message: str | None = None) -> T:
     """This function ensures that an object required by the ODX
     specification is actually present.
 

odxtools/externalaccessmethod.py

@@ -0,0 +1,22 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass
+from xml.etree import ElementTree
+
+from .element import IdentifiableElement
+from .exceptions import odxrequire
+from .odxlink import OdxDocFragment
+from .utils import dataclass_fields_asdict
+
+
+@dataclass
+class ExternalAccessMethod(IdentifiableElement):
+    method: str
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element,
+                doc_frags: list[OdxDocFragment]) -> "ExternalAccessMethod":
+        kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, doc_frags))
+
+        method = odxrequire(et_element.findtext("METHOD"))
+
+        return ExternalAccessMethod(method=method, **kwargs)

odxtools/externaldoc.py

@@ -0,0 +1,23 @@
+from dataclasses import dataclass
+from typing import Optional
+from xml.etree import ElementTree
+
+from .exceptions import odxrequire
+from .odxlink import OdxDocFragment
+
+
+@dataclass
+class ExternalDoc:
+    description: str | None
+    href: str
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element | None,
+                doc_frags: list[OdxDocFragment]) -> Optional["ExternalDoc"]:
+        if et_element is None:
+            return None
+
+        description = et_element.text
+        href = odxrequire(et_element.get("HREF"))
+
+        return ExternalDoc(description=description, href=href)

odxtools/field.py

@@ -1,6 +1,5 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import List, Optional
 from xml.etree import ElementTree
 
 from .basicstructure import BasicStructure
@@ -15,11 +14,11 @@ from .utils import dataclass_fields_asdict
 
 @dataclass
 class Field(ComplexDop):
-    structure_ref: Optional[OdxLinkRef]
-    structure_snref: Optional[str]
-    env_data_desc_ref: Optional[OdxLinkRef]
-    env_data_desc_snref: Optional[str]
-    is_visible_raw: Optional[bool]
+    structure_ref: OdxLinkRef | None
+    structure_snref: str | None
+    env_data_desc_ref: OdxLinkRef | None
+    env_data_desc_snref: str | None
+    is_visible_raw: bool | None
 
     @property
     def structure(self) -> BasicStructure:
@@ -31,7 +30,7 @@ class Field(ComplexDop):
         return self.is_visible_raw in (None, True)
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "Field":
+    def from_et(et_element: ElementTree.Element, doc_frags: list[OdxDocFragment]) -> "Field":
         kwargs = dataclass_fields_asdict(ComplexDop.from_et(et_element, doc_frags))
 
         structure_ref = OdxLinkRef.from_et(et_element.find("BASIC-STRUCTURE-REF"), doc_frags)
@@ -54,8 +53,8 @@ class Field(ComplexDop):
             **kwargs)
 
     def __post_init__(self) -> None:
-        self._structure: Optional[BasicStructure] = None
-        self._env_data_desc: Optional[EnvironmentDataDescription] = None
+        self._structure: BasicStructure | None = None
+        self._env_data_desc: EnvironmentDataDescription | None = None
         num_struct_refs = 0 if self.structure_ref is None else 1
         num_struct_refs += 0 if self.structure_snref is None else 1
 
@@ -87,5 +86,5 @@ class Field(ComplexDop):
             self._env_data_desc = resolve_snref(self.env_data_desc_snref, ddds.env_data_descs,
                                                 EnvironmentDataDescription)
 
-    def get_static_bit_length(self) -> Optional[int]:
+    def get_static_bit_length(self) -> int | None:
         return None