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

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
 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):
@@ -258,16 +25,16 @@ class SubComponent(IdentifiableElement):
 
     """
 
-    sub_component_patterns: List[SubComponentPattern]
+    sub_component_patterns: list[SubComponentPattern]
     sub_component_param_connectors: NamedItemList[SubComponentParamConnector]
     table_row_connectors: NamedItemList[TableRowConnector]
     env_data_connectors: NamedItemList[EnvDataConnector]
     dtc_connectors: NamedItemList[DtcConnector]
 
-    semantic: Optional[str]
+    semantic: str | None
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "SubComponent":
+    def from_et(et_element: ElementTree.Element, doc_frags: list[OdxDocFragment]) -> "SubComponent":
         kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, doc_frags))
 
         semantic = et_element.get("SEMANTIC")
@@ -302,7 +69,7 @@ class SubComponent(IdentifiableElement):
             dtc_connectors=NamedItemList(dtc_connectors),
             **kwargs)
 
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         result = {}
 
         for scp in self.sub_component_patterns:

odxtools/subcomponentparamconnector.py

@@ -0,0 +1,103 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass
+from typing import Any
+from xml.etree import ElementTree
+
+from .diagservice import DiagService
+from .element import IdentifiableElement
+from .exceptions import odxassert, odxraise, odxrequire
+from .nameditemlist import NamedItemList
+from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, resolve_snref
+from .parameters.parameter import Parameter
+from .snrefcontext import SnRefContext
+from .utils import dataclass_fields_asdict
+
+
+@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)

odxtools/subcomponentpattern.py

@@ -0,0 +1,42 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any
+from xml.etree import ElementTree
+
+from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
+from .snrefcontext import SnRefContext
+
+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)

odxtools/swvariable.py

@@ -1,6 +1,5 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import List, Optional
 from xml.etree import ElementTree
 
 from .element import NamedElement
@@ -10,11 +9,11 @@ from .utils import dataclass_fields_asdict
 
 @dataclass
 class SwVariable(NamedElement):
-    origin: Optional[str]
-    oid: Optional[str]
+    origin: str | None
+    oid: str | None
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "SwVariable":
+    def from_et(et_element: ElementTree.Element, doc_frags: list[OdxDocFragment]) -> "SwVariable":
         kwargs = dataclass_fields_asdict(NamedElement.from_et(et_element, doc_frags))
 
         origin = et_element.findtext("ORIGIN")

odxtools/table.py

@@ -1,73 +1,35 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import Any, Dict, List, Optional, Union
+from typing import Any
 from xml.etree import ElementTree
 
 from .admindata import AdminData
 from .dataobjectproperty import DataObjectProperty
-from .diagcomm import DiagComm
 from .element import IdentifiableElement
-from .exceptions import odxassert, odxrequire
+from .exceptions import odxassert
 from .nameditemlist import NamedItemList
-from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef, resolve_snref
+from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef
 from .snrefcontext import SnRefContext
 from .specialdatagroup import SpecialDataGroup
+from .tablediagcommconnector import TableDiagCommConnector
 from .tablerow import TableRow
 from .utils import dataclass_fields_asdict
 
 
-@dataclass
-class TableDiagCommConnector:
-    semantic: str
-
-    diag_comm_ref: Optional[OdxLinkRef]
-    diag_comm_snref: Optional[str]
-
-    @property
-    def diag_comm(self) -> DiagComm:
-        return self._diag_comm
-
-    @staticmethod
-    def from_et(et_element: ElementTree.Element,
-                doc_frags: List[OdxDocFragment]) -> "TableDiagCommConnector":
-
-        semantic = odxrequire(et_element.findtext("SEMANTIC"))
-
-        diag_comm_ref = OdxLinkRef.from_et(et_element.find("DIAG-COMM-REF"), doc_frags)
-        diag_comm_snref = None
-        if (dc_snref_elem := et_element.find("DIAG-COMM-SNREF")) is not None:
-            diag_comm_snref = odxrequire(dc_snref_elem.get("SHORT-NAME"))
-
-        return TableDiagCommConnector(
-            semantic=semantic, diag_comm_ref=diag_comm_ref, diag_comm_snref=diag_comm_snref)
-
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
-        return {}
-
-    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
-        if self.diag_comm_ref is not None:
-            self._diag_comm = odxlinks.resolve(self.diag_comm_ref, DiagComm)
-
-    def _resolve_snrefs(self, context: SnRefContext) -> None:
-        if self.diag_comm_snref is not None:
-            dl = odxrequire(context.diag_layer)
-            self._diag_comm = resolve_snref(self.diag_comm_snref, dl.diag_comms, DiagComm)
-
-
 @dataclass
 class Table(IdentifiableElement):
     """This class represents a TABLE."""
-    key_label: Optional[str]
-    struct_label: Optional[str]
-    admin_data: Optional[AdminData]
-    key_dop_ref: Optional[OdxLinkRef]
-    table_rows_raw: List[Union[TableRow, OdxLinkRef]]
-    table_diag_comm_connectors: List[TableDiagCommConnector]
-    sdgs: List[SpecialDataGroup]
-    semantic: Optional[str]
+    key_label: str | None
+    struct_label: str | None
+    admin_data: AdminData | None
+    key_dop_ref: OdxLinkRef | None
+    table_rows_raw: list[TableRow | OdxLinkRef]
+    table_diag_comm_connectors: list[TableDiagCommConnector]
+    sdgs: list[SpecialDataGroup]
+    semantic: str | None
 
     @property
-    def key_dop(self) -> Optional[DataObjectProperty]:
+    def key_dop(self) -> DataObjectProperty | None:
         """The key data object property associated with this table."""
         return self._key_dop
 
@@ -77,7 +39,7 @@ class Table(IdentifiableElement):
         return self._table_rows
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "Table":
+    def from_et(et_element: ElementTree.Element, doc_frags: list[OdxDocFragment]) -> "Table":
         """Reads a TABLE."""
         kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, doc_frags))
         odx_id = kwargs["odx_id"]
@@ -86,7 +48,7 @@ class Table(IdentifiableElement):
         admin_data = AdminData.from_et(et_element.find("ADMIN-DATA"), doc_frags)
         key_dop_ref = OdxLinkRef.from_et(et_element.find("KEY-DOP-REF"), doc_frags)
 
-        table_rows_raw: List[Union[OdxLinkRef, TableRow]] = []
+        table_rows_raw: list[OdxLinkRef | TableRow] = []
         for sub_elem in et_element:
             if sub_elem.tag == "TABLE-ROW":
                 table_rows_raw.append(
@@ -115,7 +77,7 @@ class Table(IdentifiableElement):
             semantic=semantic,
             **kwargs)
 
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         result = {self.odx_id: self}
 
         for table_row_wrapper in self.table_rows_raw:
@@ -131,7 +93,7 @@ class Table(IdentifiableElement):
         return result
 
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
-        self._key_dop: Optional[DataObjectProperty] = None
+        self._key_dop: DataObjectProperty | None = None
         if self.key_dop_ref is not None:
             self._key_dop = odxlinks.resolve(self.key_dop_ref, DataObjectProperty)
 

odxtools/tablediagcommconnector.py

@@ -0,0 +1,47 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass
+from typing import Any
+from xml.etree import ElementTree
+
+from .diagcomm import DiagComm
+from .exceptions import odxrequire
+from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef, resolve_snref
+from .snrefcontext import SnRefContext
+
+
+@dataclass
+class TableDiagCommConnector:
+    semantic: str
+
+    diag_comm_ref: OdxLinkRef | None
+    diag_comm_snref: str | None
+
+    @property
+    def diag_comm(self) -> DiagComm:
+        return self._diag_comm
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element,
+                doc_frags: list[OdxDocFragment]) -> "TableDiagCommConnector":
+
+        semantic = odxrequire(et_element.findtext("SEMANTIC"))
+
+        diag_comm_ref = OdxLinkRef.from_et(et_element.find("DIAG-COMM-REF"), doc_frags)
+        diag_comm_snref = None
+        if (dc_snref_elem := et_element.find("DIAG-COMM-SNREF")) is not None:
+            diag_comm_snref = odxrequire(dc_snref_elem.get("SHORT-NAME"))
+
+        return TableDiagCommConnector(
+            semantic=semantic, diag_comm_ref=diag_comm_ref, diag_comm_snref=diag_comm_snref)
+
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
+        return {}
+
+    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
+        if self.diag_comm_ref is not None:
+            self._diag_comm = odxlinks.resolve(self.diag_comm_ref, DiagComm)
+
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
+        if self.diag_comm_snref is not None:
+            dl = odxrequire(context.diag_layer)
+            self._diag_comm = resolve_snref(self.diag_comm_snref, dl.diag_comms, DiagComm)