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

odxtools/diagcomm.py

@@ -1,11 +1,11 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from enum import Enum
 from typing import TYPE_CHECKING, Any, Dict, List, Optional
 from xml.etree import ElementTree
 
 from .admindata import AdminData
 from .audience import Audience
+from .diagclasstype import DiagClassType
 from .element import IdentifiableElement
 from .exceptions import odxraise, odxrequire
 from .functionalclass import FunctionalClass
@@ -13,6 +13,7 @@ from .nameditemlist import NamedItemList
 from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef, resolve_snref
 from .odxtypes import odxstr_to_bool
 from .preconditionstateref import PreConditionStateRef
+from .relateddiagcommref import RelatedDiagCommRef
 from .snrefcontext import SnRefContext
 from .specialdatagroup import SpecialDataGroup
 from .state import State
@@ -24,30 +25,6 @@ if TYPE_CHECKING:
     from .diaglayers.protocol import Protocol
 
 
-class DiagClassType(Enum):
-    STARTCOMM = "STARTCOMM"
-    STOPCOMM = "STOPCOMM"
-    VARIANTIDENTIFICATION = "VARIANTIDENTIFICATION"
-    READ_DYN_DEFINED_MESSAGE = "READ-DYN-DEFINED-MESSAGE"
-    DYN_DEF_MESSAGE = "DYN-DEF-MESSAGE"
-    CLEAR_DYN_DEF_MESSAGE = "CLEAR-DYN-DEF-MESSAGE"
-
-
-@dataclass
-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)))
-
-        relation_type = odxrequire(et_element.findtext("RELATION-TYPE"))
-
-        return RelatedDiagCommRef(relation_type=relation_type, **kwargs)
-
-
 @dataclass
 class DiagComm(IdentifiableElement):
     """Representation of a diagnostic communication object.

odxtools/diagservice.py

@@ -1,9 +1,9 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from enum import Enum
 from typing import Any, Dict, List, Optional, Union, cast
 from xml.etree import ElementTree
 
+from .addressing import Addressing
 from .comparaminstance import ComparamInstance
 from .diagcomm import DiagComm
 from .exceptions import DecodeError, DecodeMismatch, odxassert, odxraise, odxrequire
@@ -12,90 +12,14 @@ from .nameditemlist import NamedItemList
 from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef
 from .odxtypes import ParameterValue, odxstr_to_bool
 from .parameters.parameter import Parameter
+from .posresponsesuppressible import PosResponseSuppressible
 from .request import Request
 from .response import Response
 from .snrefcontext import SnRefContext
+from .transmode import TransMode
 from .utils import dataclass_fields_asdict
 
 
-class Addressing(Enum):
-    FUNCTIONAL = "FUNCTIONAL"
-    PHYSICAL = "PHYSICAL"
-    FUNCTIONAL_OR_PHYSICAL = "FUNCTIONAL-OR-PHYSICAL"
-
-
-class TransMode(Enum):
-    SEND_ONLY = "SEND-ONLY"
-    RECEIVE_ONLY = "RECEIVE-ONLY"
-    SEND_AND_RECEIVE = "SEND-AND-RECEIVE"
-    SEND_OR_RECEIVE = "SEND-OR-RECEIVE"
-
-
-# note that the spec has a typo here: it calls the corresponding
-# XML tag POS-RESPONSE-SUPPRESSABLE...
-@dataclass
-class PosResponseSuppressible:
-    bit_mask: int
-
-    coded_const_snref: Optional[str]
-    coded_const_snpathref: Optional[str]
-
-    value_snref: Optional[str]
-    value_snpathref: Optional[str]
-
-    phys_const_snref: Optional[str]
-    phys_const_snpathref: Optional[str]
-
-    table_key_snref: Optional[str]
-    table_key_snpathref: Optional[str]
-
-    @staticmethod
-    def from_et(et_element: ElementTree.Element,
-                doc_frags: List[OdxDocFragment]) -> "PosResponseSuppressible":
-
-        bit_mask = int(odxrequire(et_element.findtext("BIT-MASK")))
-
-        coded_const_snref = None
-        if (cc_snref_elem := et_element.find("CODED-CONST-SNREF")) is not None:
-            coded_const_snref = cc_snref_elem.attrib["SHORT-NAME"]
-        coded_const_snpathref = None
-        if (cc_snpathref_elem := et_element.find("CODED-CONST-SNPATHREF")) is not None:
-            coded_const_snpathref = cc_snpathref_elem.attrib["SHORT-NAME-PATH"]
-
-        value_snref = None
-        if (cc_snref_elem := et_element.find("VALUE-SNREF")) is not None:
-            value_snref = cc_snref_elem.attrib["SHORT-NAME"]
-        value_snpathref = None
-        if (cc_snpathref_elem := et_element.find("VALUE-SNPATHREF")) is not None:
-            value_snpathref = cc_snpathref_elem.attrib["SHORT-NAME-PATH"]
-
-        phys_const_snref = None
-        if (cc_snref_elem := et_element.find("PHYS-CONST-SNREF")) is not None:
-            phys_const_snref = cc_snref_elem.attrib["SHORT-NAME"]
-        phys_const_snpathref = None
-        if (cc_snpathref_elem := et_element.find("PHYS-CONST-SNPATHREF")) is not None:
-            phys_const_snpathref = cc_snpathref_elem.attrib["SHORT-NAME-PATH"]
-
-        table_key_snref = None
-        if (cc_snref_elem := et_element.find("TABLE-KEY-SNREF")) is not None:
-            table_key_snref = cc_snref_elem.attrib["SHORT-NAME"]
-        table_key_snpathref = None
-        if (cc_snpathref_elem := et_element.find("TABLE-KEY-SNPATHREF")) is not None:
-            table_key_snpathref = cc_snpathref_elem.attrib["SHORT-NAME-PATH"]
-
-        return PosResponseSuppressible(
-            bit_mask=bit_mask,
-            coded_const_snref=coded_const_snref,
-            coded_const_snpathref=coded_const_snpathref,
-            value_snref=value_snref,
-            value_snpathref=value_snpathref,
-            phys_const_snref=phys_const_snref,
-            phys_const_snpathref=phys_const_snpathref,
-            table_key_snref=table_key_snref,
-            table_key_snpathref=table_key_snpathref,
-        )
-
-
 @dataclass
 class DiagService(DiagComm):
     """Representation of a diagnostic service description.

odxtools/dtcconnector.py

@@ -0,0 +1,45 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass
+from typing import Any, Dict, List
+from xml.etree import ElementTree
+
+from .diagnostictroublecode import DiagnosticTroubleCode
+from .dtcdop import DtcDop
+from .element import NamedElement
+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 DtcConnector(NamedElement):
+    dtc_dop_ref: OdxLinkRef
+    dtc_snref: str
+
+    @property
+    def dtc_dop(self) -> DtcDop:
+        return self._dtc_dop
+
+    @property
+    def dtc(self) -> DiagnosticTroubleCode:
+        return self._dtc
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "DtcConnector":
+        kwargs = dataclass_fields_asdict(NamedElement.from_et(et_element, doc_frags))
+
+        dtc_dop_ref = odxrequire(OdxLinkRef.from_et(et_element.find("DTC-DOP-REF"), doc_frags))
+        dtc_snref_el = odxrequire(et_element.find("DTC-SNREF"))
+        dtc_snref = odxrequire(dtc_snref_el.get("SHORT-NAME"))
+
+        return DtcConnector(dtc_dop_ref=dtc_dop_ref, dtc_snref=dtc_snref, **kwargs)
+
+    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+        return {}
+
+    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
+        self._dtc_dop = odxlinks.resolve(self.dtc_dop_ref, DtcDop)
+
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
+        self._dtc = resolve_snref(self.dtc_snref, self._dtc_dop.dtcs, DiagnosticTroubleCode)

odxtools/dtcdop.py

@@ -14,60 +14,15 @@ from .diagnostictroublecode import DiagnosticTroubleCode
 from .dopbase import DopBase
 from .encodestate import EncodeState
 from .exceptions import DecodeError, EncodeError, odxassert, odxraise, odxrequire
+from .linkeddtcdop import LinkedDtcDop
 from .nameditemlist import NamedItemList
-from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef, resolve_snref
+from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef
 from .odxtypes import ParameterValue, odxstr_to_bool
 from .physicaltype import PhysicalType
 from .snrefcontext import SnRefContext
 from .utils import dataclass_fields_asdict
 
 
-@dataclass
-class LinkedDtcDop:
-    not_inherited_dtc_snrefs: List[str]
-    dtc_dop_ref: OdxLinkRef
-
-    @property
-    def not_inherited_dtcs(self) -> NamedItemList[DiagnosticTroubleCode]:
-        return self._not_inherited_dtcs
-
-    @property
-    def dtc_dop(self) -> "DtcDop":
-        return self._dtc_dop
-
-    @property
-    def short_name(self) -> str:
-        return self._dtc_dop.short_name
-
-    @staticmethod
-    def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "LinkedDtcDop":
-        not_inherited_dtc_snrefs = [
-            odxrequire(el.get("SHORT-NAME"))
-            for el in et_element.iterfind("NOT-INHERITED-DTC-SNREFS/"
-                                          "NOT-INHERITED-DTC-SNREF")
-        ]
-
-        dtc_dop_ref = odxrequire(OdxLinkRef.from_et(et_element.find("DTC-DOP-REF"), doc_frags))
-
-        return LinkedDtcDop(
-            not_inherited_dtc_snrefs=not_inherited_dtc_snrefs, dtc_dop_ref=dtc_dop_ref)
-
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
-        return {}
-
-    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
-        self._dtc_dop = odxlinks.resolve(self.dtc_dop_ref, DtcDop)
-
-    def _resolve_snrefs(self, context: SnRefContext) -> None:
-        dtc_dop = self._dtc_dop
-        not_inherited_dtcs = [
-            resolve_snref(ni_snref, dtc_dop.dtcs, DiagnosticTroubleCode)
-            for ni_snref in self.not_inherited_dtc_snrefs
-        ]
-
-        self._not_inherited_dtcs = NamedItemList(not_inherited_dtcs)
-
-
 @dataclass
 class DtcDop(DopBase):
     """A DOP describing a diagnostic trouble code"""

odxtools/dyndefinedspec.py

@@ -1,163 +1,11 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import Any, Dict, List, Optional, Union
+from typing import Any, Dict, List
 from xml.etree import ElementTree
 
-from .diagcomm import DiagClassType, DiagComm
-from .exceptions import odxassert, odxraise, odxrequire
-from .nameditemlist import NamedItemList
-from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef, resolve_snref
+from .dyniddefmodeinfo import DynIdDefModeInfo
+from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
 from .snrefcontext import SnRefContext
-from .table import Table
-
-
-@dataclass
-class DynIdDefModeInfo:
-    def_mode: str
-
-    clear_dyn_def_message_ref: Optional[OdxLinkRef]
-    clear_dyn_def_message_snref: Optional[str]
-
-    read_dyn_def_message_ref: Optional[OdxLinkRef]
-    read_dyn_def_message_snref: Optional[str]
-
-    dyn_def_message_ref: Optional[OdxLinkRef]
-    dyn_def_message_snref: Optional[str]
-
-    supported_dyn_ids: List[bytes]
-    selection_table_refs: List[Union[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[Union[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))
 
 
 @dataclass

odxtools/dyniddefmodeinfo.py

@@ -0,0 +1,161 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass
+from typing import Any, Dict, List, Optional, Union
+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: Optional[OdxLinkRef]
+    clear_dyn_def_message_snref: Optional[str]
+
+    read_dyn_def_message_ref: Optional[OdxLinkRef]
+    read_dyn_def_message_snref: Optional[str]
+
+    dyn_def_message_ref: Optional[OdxLinkRef]
+    dyn_def_message_snref: Optional[str]
+
+    supported_dyn_ids: List[bytes]
+    selection_table_refs: List[Union[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[Union[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/envdataconnector.py

@@ -0,0 +1,49 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass
+from typing import Any, Dict, List
+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/externalaccessmethod.py

@@ -0,0 +1,23 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass
+from typing import List
+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)