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

odxtools/externaldoc.py

@@ -0,0 +1,23 @@
+from dataclasses import dataclass
+from typing import List, Optional
+from xml.etree import ElementTree
+
+from .exceptions import odxrequire
+from .odxlink import OdxDocFragment
+
+
+@dataclass
+class ExternalDoc:
+    description: Optional[str]
+    href: str
+
+    @staticmethod
+    def from_et(et_element: Optional[ElementTree.Element],
+                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/linkeddtcdop.py

@@ -0,0 +1,62 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any, Dict, List
+from xml.etree import ElementTree
+
+from .diagnostictroublecode import DiagnosticTroubleCode
+from .exceptions import odxrequire
+from .nameditemlist import NamedItemList
+from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef, resolve_snref
+from .snrefcontext import SnRefContext
+
+if TYPE_CHECKING:
+    from .dtcdop import DtcDop
+
+
+@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:
+        if TYPE_CHECKING:
+            self._dtc_dop = odxlinks.resolve(self.dtc_dop_ref, DtcDop)
+        else:
+            self._dtc_dop = odxlinks.resolve(self.dtc_dop_ref)
+
+    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)

odxtools/minmaxlengthtype.py

@@ -1,6 +1,5 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from enum import Enum
 from typing import List, Optional, cast
 from xml.etree import ElementTree
 
@@ -13,15 +12,10 @@ from .encoding import get_string_encoding
 from .exceptions import DecodeError, EncodeError, odxassert, odxraise, odxrequire
 from .odxlink import OdxDocFragment
 from .odxtypes import AtomicOdxType, BytesTypes, DataType
+from .termination import Termination
 from .utils import dataclass_fields_asdict
 
 
-class Termination(Enum):
-    END_OF_PDU = "END-OF-PDU"
-    ZERO = "ZERO"
-    HEX_FF = "HEX-FF"
-
-
 @dataclass
 class MinMaxLengthType(DiagCodedType):
     max_length: Optional[int]

odxtools/parameterinfo.py

@@ -5,7 +5,7 @@ from typing import Iterable
 
 from .compumethods.compucodecompumethod import CompuCodeCompuMethod
 from .compumethods.identicalcompumethod import IdenticalCompuMethod
-from .compumethods.limit import IntervalType
+from .compumethods.intervaltype import IntervalType
 from .compumethods.linearcompumethod import LinearCompuMethod
 from .compumethods.linearsegment import LinearSegment
 from .compumethods.ratfunccompumethod import RatFuncCompuMethod

odxtools/parameters/rowfragment.py

@@ -0,0 +1,7 @@
+# SPDX-License-Identifier: MIT
+from enum import Enum
+
+
+class RowFragment(Enum):
+    KEY = "KEY"
+    STRUCT = "STRUCT"

odxtools/parameters/tableentryparameter.py

@@ -1,6 +1,5 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from enum import Enum
 from typing import TYPE_CHECKING, List, Optional, cast
 from xml.etree import ElementTree
 
@@ -13,16 +12,12 @@ from ..odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkRef
 from ..odxtypes import ParameterValue
 from ..utils import dataclass_fields_asdict
 from .parameter import Parameter, ParameterType
+from .rowfragment import RowFragment
 
 if TYPE_CHECKING:
     from ..tablerow import TableRow
 
 
-class RowFragment(Enum):
-    KEY = "KEY"
-    STRUCT = "STRUCT"
-
-
 @dataclass
 class TableEntryParameter(Parameter):
     target: RowFragment

odxtools/physicaltype.py

@@ -1,19 +1,12 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from enum import IntEnum
 from typing import List, Optional
 from xml.etree import ElementTree
 
 from .exceptions import odxraise
 from .odxlink import OdxDocFragment
 from .odxtypes import DataType
-
-
-class Radix(IntEnum):
-    HEX = 16
-    DEC = 10
-    BIN = 2
-    OCT = 8
+from .radix import Radix
 
 
 @dataclass

odxtools/posresponsesuppressible.py

@@ -0,0 +1,73 @@
+# 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 .utils import read_hex_binary
+
+
+# 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 = odxrequire(read_hex_binary(et_element.find("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,
+        )

odxtools/radix.py

@@ -0,0 +1,9 @@
+# SPDX-License-Identifier: MIT
+from enum import IntEnum
+
+
+class Radix(IntEnum):
+    HEX = 16
+    DEC = 10
+    BIN = 2
+    OCT = 8

odxtools/relateddiagcommref.py

@@ -0,0 +1,23 @@
+# 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 .utils import dataclass_fields_asdict
+
+
+@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)

odxtools/request.py

@@ -4,9 +4,11 @@ from typing import Any, Dict, List, Optional, cast
 from xml.etree import ElementTree
 
 from .admindata import AdminData
-from .codec import (composite_codec_decode_from_pdu, composite_codec_encode_into_pdu,
-                    composite_codec_get_coded_const_prefix, composite_codec_get_free_parameters,
-                    composite_codec_get_required_parameters, composite_codec_get_static_bit_length)
+from .compositecodec import (composite_codec_decode_from_pdu, composite_codec_encode_into_pdu,
+                             composite_codec_get_coded_const_prefix,
+                             composite_codec_get_free_parameters,
+                             composite_codec_get_required_parameters,
+                             composite_codec_get_static_bit_length)
 from .decodestate import DecodeState
 from .element import IdentifiableElement
 from .encodestate import EncodeState

odxtools/response.py

@@ -5,9 +5,11 @@ from typing import Any, Dict, List, Optional, cast
 from xml.etree import ElementTree
 
 from .admindata import AdminData
-from .codec import (composite_codec_decode_from_pdu, composite_codec_encode_into_pdu,
-                    composite_codec_get_coded_const_prefix, composite_codec_get_free_parameters,
-                    composite_codec_get_required_parameters, composite_codec_get_static_bit_length)
+from .compositecodec import (composite_codec_decode_from_pdu, composite_codec_encode_into_pdu,
+                             composite_codec_get_coded_const_prefix,
+                             composite_codec_get_free_parameters,
+                             composite_codec_get_required_parameters,
+                             composite_codec_get_static_bit_length)
 from .decodestate import DecodeState
 from .element import IdentifiableElement
 from .encodestate import EncodeState

odxtools/scaleconstr.py

@@ -1,6 +1,5 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from enum import Enum
 from typing import List, Optional
 from xml.etree import ElementTree
 
@@ -9,13 +8,7 @@ from .description import Description
 from .exceptions import odxraise, odxrequire
 from .odxlink import OdxDocFragment
 from .odxtypes import DataType
-
-
-class ValidType(Enum):
-    VALID = "VALID"
-    NOT_VALID = "NOT-VALID"
-    NOT_DEFINED = "NOT-DEFINED"
-    NOT_AVAILABLE = "NOT-AVAILABLE"
+from .validtype import ValidType
 
 
 @dataclass

odxtools/standardizationlevel.py

@@ -0,0 +1,9 @@
+# SPDX-License-Identifier: MIT
+from enum import Enum
+
+
+class StandardizationLevel(Enum):
+    STANDARD = "STANDARD"
+    OEM_SPECIFIC = "OEM-SPECIFIC"
+    OPTIONAL = "OPTIONAL"
+    OEM_OPTIONAL = "OEM-OPTIONAL"

odxtools/standardlengthtype.py

@@ -11,7 +11,7 @@ from .encodestate import EncodeState
 from .exceptions import odxassert, odxraise, odxrequire
 from .odxlink import OdxDocFragment
 from .odxtypes import AtomicOdxType, BytesTypes, DataType, odxstr_to_bool
-from .utils import dataclass_fields_asdict
+from .utils import dataclass_fields_asdict, read_hex_binary
 
 
 @dataclass
@@ -36,16 +36,7 @@ class StandardLengthType(DiagCodedType):
         kwargs = dataclass_fields_asdict(DiagCodedType.from_et(et_element, doc_frags))
 
         bit_length = int(odxrequire(et_element.findtext("BIT-LENGTH")))
-        bit_mask = None
-        if (bit_mask_str := et_element.findtext("BIT-MASK")) is not None:
-            # The XSD uses the type xsd:hexBinary
-            # xsd:hexBinary allows for leading/trailing whitespace, empty strings, and it only allows an even
-            # number of hex digits, while some of the examples shown in the  ODX specification exhibit an
-            # odd number of hex digits.
-            # This causes a validation paradox, so we try to be flexible
-            bit_mask_str = bit_mask_str.strip()
-            if len(bit_mask_str):
-                bit_mask = int(bit_mask_str, 16)
+        bit_mask = read_hex_binary(et_element.find("BIT-MASK"))
         is_condensed_raw = odxstr_to_bool(et_element.get("IS-CONDENSED"))
 
         return StandardLengthType(

odxtools/statetransition.py

@@ -5,26 +5,13 @@ from xml.etree import ElementTree
 
 from .element import IdentifiableElement
 from .exceptions import odxrequire
+from .externalaccessmethod import ExternalAccessMethod
 from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, resolve_snref
 from .snrefcontext import SnRefContext
 from .state import State
 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)
-
-
 @dataclass
 class StateTransition(IdentifiableElement):
     """

odxtools/subcomponent.py

@@ -1,252 +1,19 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Dict, List, Optional
+from typing import Any, Dict, List, Optional
 from xml.etree import ElementTree
 
-from .diagnostictroublecode import DiagnosticTroubleCode
-from .diagservice import DiagService
-from .dtcdop import DtcDop
-from .element import IdentifiableElement, NamedElement
-from .environmentdata import EnvironmentData
-from .environmentdatadescription import EnvironmentDataDescription
-from .exceptions import odxassert, odxraise, odxrequire
+from .dtcconnector import DtcConnector
+from .element import IdentifiableElement
+from .envdataconnector import EnvDataConnector
 from .nameditemlist import NamedItemList
-from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef, resolve_snref
-from .parameters.parameter import Parameter
+from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
 from .snrefcontext import SnRefContext
-from .table import Table
-from .tablerow import TableRow
+from .subcomponentparamconnector import SubComponentParamConnector
+from .subcomponentpattern import SubComponentPattern
+from .tablerowconnector import TableRowConnector
 from .utils import dataclass_fields_asdict
 
-if TYPE_CHECKING:
-    from .matchingparameter import MatchingParameter
-
-
-@dataclass
-class SubComponentPattern:
-    matching_parameters: List["MatchingParameter"]
-
-    @staticmethod
-    def from_et(et_element: ElementTree.Element,
-                doc_frags: List[OdxDocFragment]) -> "SubComponentPattern":
-        from .matchingparameter import MatchingParameter
-
-        matching_parameters = [
-            MatchingParameter.from_et(el, doc_frags)
-            for el in et_element.iterfind("MATCHING-PARAMETERS/MATCHING-PARAMETER")
-        ]
-
-        return SubComponentPattern(matching_parameters=matching_parameters)
-
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
-        result = {}
-        for mp in self.matching_parameters:
-            result.update(mp._build_odxlinks())
-
-        return result
-
-    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
-        for mp in self.matching_parameters:
-            mp._resolve_odxlinks(odxlinks)
-
-    def _resolve_snrefs(self, context: SnRefContext) -> None:
-        for mp in self.matching_parameters:
-            mp._resolve_snrefs(context)
-
-
-@dataclass
-class SubComponentParamConnector(IdentifiableElement):
-    diag_comm_snref: str
-
-    # TODO: we currently only support SNREFs, not SNPATHREFs
-    out_param_if_refs: List[str]
-    in_param_if_refs: List[str]
-
-    @property
-    def service(self) -> DiagService:
-        return self._service
-
-    @property
-    def out_param_ifs(self) -> NamedItemList[Parameter]:
-        return self._out_param_ifs
-
-    @property
-    def in_param_ifs(self) -> NamedItemList[Parameter]:
-        return self._in_param_ifs
-
-    @staticmethod
-    def from_et(et_element: ElementTree.Element,
-                doc_frags: List[OdxDocFragment]) -> "SubComponentParamConnector":
-        kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, doc_frags))
-
-        diag_comm_snref = odxrequire(
-            odxrequire(et_element.find("DIAG-COMM-SNREF")).get("SHORT-NAME"))
-
-        out_param_if_refs = []
-        for elem in et_element.find("OUT-PARAM-IF-REFS") or []:
-            if elem.tag != "OUT-PARAM-IF-SNREF":
-                odxraise("Currently, only SNREFS are supported for OUT-PARAM-IF-REFS")
-                continue
-            else:
-                odxassert(elem.tag == "OUT-PARAM-IF-SNREF")
-                out_param_if_refs.append(odxrequire(elem.attrib.get("SHORT-NAME")))
-
-        in_param_if_refs = []
-        for elem in et_element.find("IN-PARAM-IF-REFS") or []:
-            if elem.tag != "IN-PARAM-IF-SNREF":
-                odxraise("Currently, only SNREFS are supported for IN-PARAM-IF-REFS")
-                continue
-            else:
-                odxassert(elem.tag == "IN-PARAM-IF-SNREF")
-                in_param_if_refs.append(odxrequire(elem.attrib.get("SHORT-NAME")))
-
-        return SubComponentParamConnector(
-            diag_comm_snref=diag_comm_snref,
-            out_param_if_refs=out_param_if_refs,
-            in_param_if_refs=in_param_if_refs,
-            **kwargs)
-
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
-        return {}
-
-    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
-        pass
-
-    def _resolve_snrefs(self, context: SnRefContext) -> None:
-        service = resolve_snref(self.diag_comm_snref,
-                                odxrequire(context.diag_layer).diag_comms, DiagService)
-        self._service = service
-
-        if self._service.request is not None:
-            odxraise()
-            return
-        if not self._service.positive_responses:
-            odxraise()
-            return
-
-        request = odxrequire(service.request)
-        in_param_ifs = []
-        for x in self.in_param_if_refs:
-            in_param_ifs.append(resolve_snref(x, request.parameters, Parameter))
-
-        # TODO: The output parameters are probably part of a response
-        # (?). If so, they cannot be resolved ahead of time because
-        # the service in question can have multiple responses
-        # associated with it and each of these has its own set of
-        # parameters. In the meantime, we simply use the first
-        # positive response specified.
-        response = service.positive_responses[0]
-        out_param_ifs = []
-        for x in self.out_param_if_refs:
-            out_param_ifs.append(resolve_snref(x, response.parameters, Parameter))
-
-        self._in_param_ifs = NamedItemList(in_param_ifs)
-        self._out_param_ifs = NamedItemList(out_param_ifs)
-
-
-@dataclass
-class TableRowConnector(NamedElement):
-    table_ref: OdxLinkRef
-    table_row_snref: str
-
-    @property
-    def table(self) -> Table:
-        return self._table
-
-    @property
-    def table_row(self) -> TableRow:
-        return self._table_row
-
-    @staticmethod
-    def from_et(et_element: ElementTree.Element,
-                doc_frags: List[OdxDocFragment]) -> "TableRowConnector":
-        kwargs = dataclass_fields_asdict(NamedElement.from_et(et_element, doc_frags))
-
-        table_ref = odxrequire(OdxLinkRef.from_et(et_element.find("TABLE-REF"), doc_frags))
-        table_row_snref_el = odxrequire(et_element.find("TABLE-ROW-SNREF"))
-        table_row_snref = odxrequire(table_row_snref_el.get("SHORT-NAME"))
-
-        return TableRowConnector(table_ref=table_ref, table_row_snref=table_row_snref, **kwargs)
-
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
-        return {}
-
-    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
-        self._table = odxlinks.resolve(self.table_ref, Table)
-
-    def _resolve_snrefs(self, context: SnRefContext) -> None:
-        self._table_row = resolve_snref(self.table_row_snref, self._table.table_rows, TableRow)
-
-
-@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)
-
-
-@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)
-
 
 @dataclass
 class SubComponent(IdentifiableElement):