odxtools 6.6.1__py3-none-any.whl → 9.3.0__py3-none-any.whl

odxtools/standardlengthtype.py

@@ -1,12 +1,17 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import Optional
+from typing import List, Literal, Optional
+from xml.etree import ElementTree
+
+from typing_extensions import override
 
 from .decodestate import DecodeState
 from .diagcodedtype import DctType, DiagCodedType
 from .encodestate import EncodeState
-from .exceptions import odxassert, odxraise
-from .odxtypes import AtomicOdxType, DataType
+from .exceptions import odxassert, odxraise, odxrequire
+from .odxlink import OdxDocFragment
+from .odxtypes import AtomicOdxType, DataType, odxstr_to_bool
+from .utils import dataclass_fields_asdict
 
 
 @dataclass
@@ -16,10 +21,36 @@ class StandardLengthType(DiagCodedType):
     bit_mask: Optional[int]
     is_condensed_raw: Optional[bool]
 
+    @staticmethod
+    @override
+    def from_et(et_element: ElementTree.Element,
+                doc_frags: List[OdxDocFragment]) -> "StandardLengthType":
+        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)
+        is_condensed_raw = odxstr_to_bool(et_element.get("IS-CONDENSED"))
+
+        return StandardLengthType(
+            bit_length=bit_length, bit_mask=bit_mask, is_condensed_raw=is_condensed_raw, **kwargs)
+
     @property
     def dct_type(self) -> DctType:
         return "STANDARD-LENGTH-TYPE"
 
+    @property
+    def is_condensed(self) -> bool:
+        return self.is_condensed_raw is True
+
     def __post_init__(self) -> None:
         if self.bit_mask is not None:
             maskable_types = (DataType.A_UINT32, DataType.A_INT32, DataType.A_BYTEFIELD)
@@ -28,11 +59,46 @@ class StandardLengthType(DiagCodedType):
                 'Can not apply a bit_mask on a value of type {self.base_data_type}',
             )
 
+    def __get_raw_mask(self, internal_value: AtomicOdxType) -> Optional[bytes]:
+        """Returns a byte field where all bits that are used by the
+        DiagCoded type are set and all unused ones are not set.
+
+        If `None` is returned, all bits are used.
+        """
+        if self.bit_mask is None:
+            return None
+
+        if self.is_condensed:
+            odxraise("Condensed bit masks are not yet supported", NotImplementedError)
+            return
+
+        endianness: Literal["little", "big"] = "big"
+        if not self.is_highlow_byte_order and self.base_data_type in [
+                DataType.A_INT32, DataType.A_UINT32, DataType.A_FLOAT32, DataType.A_FLOAT64
+        ]:
+            # TODO (?): Technically, little endian A_UNICODE2STRING
+            # objects require a byte swap for each 16 bit letter, and
+            # thus also for the mask. I somehow doubt that this has
+            # been anticipated by the standard, though...
+            endianness = "little"
+
+        sz: int
+        if isinstance(internal_value, (bytes, bytearray)):
+            sz = len(internal_value)
+        else:
+            sz = (odxrequire(self.get_static_bit_length()) + 7) // 8
+
+        max_value = (1 << (sz * 8)) - 1
+        bit_mask = self.bit_mask & max_value
+
+        return bit_mask.to_bytes(sz, endianness)
+
     def __apply_mask(self, internal_value: AtomicOdxType) -> AtomicOdxType:
         if self.bit_mask is None:
             return internal_value
-        if self.is_condensed_raw is True:
-            raise NotImplementedError("Serialization of condensed bit mask is not supported")
+        if self.is_condensed:
+            odxraise("Serialization of condensed bit mask is not supported", NotImplementedError)
+            return
         if isinstance(internal_value, int):
             return internal_value & self.bit_mask
         if isinstance(internal_value, bytes):
@@ -46,16 +112,16 @@ class StandardLengthType(DiagCodedType):
     def get_static_bit_length(self) -> Optional[int]:
         return self.bit_length
 
-    def convert_internal_to_bytes(self, internal_value: AtomicOdxType, encode_state: EncodeState,
-                                  bit_position: int) -> bytes:
-        return self._encode_internal_value(
-            self.__apply_mask(internal_value),
-            bit_position,
-            self.bit_length,
-            self.base_data_type,
-            is_highlow_byte_order=self.is_highlow_byte_order,
-        )
+    @override
+    def encode_into_pdu(self, internal_value: AtomicOdxType, encode_state: EncodeState) -> None:
+        encode_state.emplace_atomic_value(
+            internal_value=self.__apply_mask(internal_value),
+            used_mask=self.__get_raw_mask(internal_value),
+            bit_length=self.bit_length,
+            base_data_type=self.base_data_type,
+            is_highlow_byte_order=self.is_highlow_byte_order)
 
+    @override
     def decode_from_pdu(self, decode_state: DecodeState) -> AtomicOdxType:
         internal_value = decode_state.extract_atomic_value(
             self.bit_length,

odxtools/state.py

@@ -1,15 +1,13 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Dict, List
+from typing import Any, Dict, List
 from xml.etree import ElementTree
 
 from .element import IdentifiableElement
 from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
+from .snrefcontext import SnRefContext
 from .utils import dataclass_fields_asdict
 
-if TYPE_CHECKING:
-    from .diaglayer import DiagLayer
-
 
 @dataclass
 class State(IdentifiableElement):
@@ -29,5 +27,5 @@ class State(IdentifiableElement):
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
         pass
 
-    def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
         pass

odxtools/statechart.py

@@ -1,19 +1,17 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Dict, List
+from typing import Any, Dict, List
 from xml.etree import ElementTree
 
 from .element import IdentifiableElement
 from .exceptions import odxrequire
 from .nameditemlist import NamedItemList
-from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
+from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, resolve_snref
+from .snrefcontext import SnRefContext
 from .state import State
 from .statetransition import StateTransition
 from .utils import dataclass_fields_asdict
 
-if TYPE_CHECKING:
-    from .diaglayer import DiagLayer
-
 
 @dataclass
 class StateChart(IdentifiableElement):
@@ -68,25 +66,21 @@ class StateChart(IdentifiableElement):
         for st in self.states:
             st._resolve_odxlinks(odxlinks)
 
-        # For now, we assume that the start state short name ref
-        # points to a state local to the state chart. TODO: The XML
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
+        context.state_chart = self
+
+        # For now, we assume that the start state short name reference
+        # points to a local state of the state chart. TODO: The XSD
         # allows to define state charts without any states, yet the
         # start state SNREF is mandatory. Is this a gap in the spec or
         # does it allow "foreign" start states? If the latter, what
         # does that mean?
-        self._start_state: State
-        for st in self.states:
-            if st.short_name == self.start_state_snref:
-                self._start_state = st
-                break
+        self._start_state = resolve_snref(self.start_state_snref, self.states, State)
 
-    def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
         for st in self.states:
-            st._resolve_snrefs(diag_layer)
+            st._resolve_snrefs(context)
 
         for strans in self.state_transitions:
-            # note that the signature of the state transition's
-            # _resolve_snrefs() method is non-standard as the
-            # namespace of these SNREFs is the state chart, not the
-            # whole diag layer...
-            strans._resolve_snrefs(diag_layer, states=self.states)
+            strans._resolve_snrefs(context)
+
+        context.state_chart = None

odxtools/statetransition.py

@@ -1,17 +1,15 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Dict, Iterable, List
+from typing import Any, Dict, List
 from xml.etree import ElementTree
 
 from .element import IdentifiableElement
 from .exceptions import odxrequire
-from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
+from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, resolve_snref
+from .snrefcontext import SnRefContext
 from .state import State
 from .utils import dataclass_fields_asdict
 
-if TYPE_CHECKING:
-    from .diaglayer import DiagLayer
-
 
 @dataclass
 class StateTransition(IdentifiableElement):
@@ -20,7 +18,7 @@ class StateTransition(IdentifiableElement):
     """
     source_snref: str
     target_snref: str
-    #external_access_method: Optional[ExternalAccessMethod] # TODO
+    # external_access_method: Optional[ExternalAccessMethod] # TODO
 
     @property
     def source_state(self) -> State:
@@ -50,15 +48,7 @@ class StateTransition(IdentifiableElement):
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
         pass
 
-    # note that the signature of this method is non-standard because
-    # the namespace of these SNREFs is the corresponding state
-    # chart. To mitigate this a bit, the non-standard parameters are
-    # keyword-only...
-    def _resolve_snrefs(self, diag_layer: "DiagLayer", *, states: Iterable[State]) -> None:
-        self._source_state: State
-        self._target_state: State
-        for st in states:
-            if st.short_name == self.source_snref:
-                self._source_state = st
-            if st.short_name == self.target_snref:
-                self._target_state = st
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
+        states = odxrequire(context.state_chart).states
+        self._source_state = resolve_snref(self.source_snref, states, State)
+        self._target_state = resolve_snref(self.target_snref, states, State)

odxtools/staticfield.py

@@ -0,0 +1,107 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass
+from typing import Any, Dict, List, Sequence
+from xml.etree import ElementTree
+
+from typing_extensions import override
+
+from .decodestate import DecodeState
+from .encodestate import EncodeState
+from .exceptions import odxassert, odxraise, odxrequire
+from .field import Field
+from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
+from .odxtypes import ParameterValue
+from .snrefcontext import SnRefContext
+from .utils import dataclass_fields_asdict
+
+
+@dataclass
+class StaticField(Field):
+    """Array of a fixed number of structure objects"""
+    fixed_number_of_items: int
+    item_byte_size: int
+
+    @staticmethod
+    @override
+    def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "StaticField":
+        kwargs = dataclass_fields_asdict(Field.from_et(et_element, doc_frags))
+
+        fixed_number_of_items = int(odxrequire(et_element.findtext('FIXED-NUMBER-OF-ITEMS')))
+        item_byte_size = int(odxrequire(et_element.findtext('ITEM-BYTE-SIZE')))
+
+        return StaticField(
+            fixed_number_of_items=fixed_number_of_items, item_byte_size=item_byte_size, **kwargs)
+
+    @override
+    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+        odxlinks = super()._build_odxlinks()
+        return odxlinks
+
+    @override
+    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
+        super()._resolve_odxlinks(odxlinks)
+
+    @override
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
+        super()._resolve_snrefs(context)
+
+    @override
+    def encode_into_pdu(self, physical_value: ParameterValue, encode_state: EncodeState) -> None:
+
+        if not isinstance(physical_value,
+                          Sequence) or len(physical_value) != self.fixed_number_of_items:
+            odxraise(f"Value for static field '{self.short_name}' "
+                     f"must be a list of size {self.fixed_number_of_items}")
+
+        orig_is_end_of_pdu = encode_state.is_end_of_pdu
+        encode_state.is_end_of_pdu = False
+        for i, val in enumerate(physical_value):
+            if not isinstance(val, dict):
+                odxraise(f"The individual parameter values for static field '{self.short_name}' "
+                         f"must be dictionaries for structure '{self.structure.short_name}'")
+
+            if i == len(physical_value) - 1:
+                encode_state.is_end_of_pdu = orig_is_end_of_pdu
+
+            pos_before = encode_state.cursor_byte_position
+            self.structure.encode_into_pdu(val, encode_state)
+            pos_after = encode_state.cursor_byte_position
+
+            if pos_after - pos_before > self.item_byte_size:
+                odxraise(
+                    f"Insufficient item byte size for static field {self.short_name}: "
+                    f"Is {self.item_byte_size} bytes, but need at least {pos_after - pos_before} bytes"
+                )
+                encode_state.cursor_byte_position = pos_before + self.item_byte_size
+            elif pos_after - pos_before < self.item_byte_size:
+                # add some padding bytes
+                encode_state.emplace_bytes(b'\x00' * (self.item_byte_size -
+                                                      (pos_after - pos_before)))
+
+        encode_state.is_end_of_pdu = orig_is_end_of_pdu
+
+    @override
+    def decode_from_pdu(self, decode_state: DecodeState) -> ParameterValue:
+
+        odxassert(decode_state.cursor_bit_position == 0,
+                  "No bit position can be specified for static length fields!")
+
+        orig_origin = decode_state.origin_byte_position
+        decode_state.origin_byte_position = decode_state.cursor_byte_position
+
+        result: List[ParameterValue] = []
+        for _ in range(self.fixed_number_of_items):
+            orig_cursor = decode_state.cursor_byte_position
+
+            if decode_state.cursor_byte_position - orig_cursor > self.item_byte_size:
+                odxraise(f"Insufficient item byte size for static field {self.short_name}: "
+                         f"Is {self.item_byte_size} bytes, but need at least "
+                         f"{decode_state.cursor_byte_position - orig_cursor} bytes")
+
+            result.append(self.structure.decode_from_pdu(decode_state))
+
+            decode_state.cursor_byte_position = orig_cursor + self.item_byte_size
+
+        decode_state.origin_byte_position = orig_origin
+
+        return result

odxtools/subcomponent.py

@@ -0,0 +1,288 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass
+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 odxraise, odxrequire
+from .matchingparameter import MatchingParameter
+from .nameditemlist import NamedItemList
+from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef, resolve_snref
+from .parameters.parameter import Parameter
+from .snrefcontext import SnRefContext
+from .table import Table
+from .tablerow import TableRow
+from .utils import dataclass_fields_asdict
+
+
+@dataclass
+class SubComponentPattern:
+    matching_parameters: List[MatchingParameter]
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element,
+                doc_frags: List[OdxDocFragment]) -> "SubComponentPattern":
+
+        matching_parameters = [
+            MatchingParameter.from_et(el, doc_frags)
+            for el in et_element.iterfind("MATCHING-PARAMETERS/MATCHING-PARAMETER")
+        ]
+
+        return SubComponentPattern(matching_parameters=matching_parameters)
+
+
+@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
+
+            out_param_if_refs.append(odxrequire(elem.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
+
+            in_param_if_refs.append(odxrequire(elem.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)
+        response = service.positive_responses[0]
+
+        in_param_ifs = []
+        for x in self.in_param_if_refs:
+            in_param_ifs.append(resolve_snref(x, request.parameters, Parameter))
+
+        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):
+    """Sub-components describe collections of related diagnostic variables
+
+    Note that the communication paradigm via diagnostic variables is
+    somewhat uncommon. If your ECU does not define any, there's no
+    need for it to define sub-components.
+
+    """
+
+    #sub_component_patterns: NamedItemList[SubComponentPattern]
+    sub_component_param_connectors: NamedItemList[SubComponentParamConnector]
+    table_row_connectors: NamedItemList[TableRowConnector]
+    env_data_connectors: NamedItemList[EnvDataConnector]
+    dtc_connectors: NamedItemList[DtcConnector]
+
+    semantic: Optional[str]
+
+    @staticmethod
+    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")
+
+        sub_component_param_connectors = [
+            SubComponentParamConnector.from_et(el, doc_frags) for el in et_element.iterfind(
+                "SUB-COMPONENT-PARAM-CONNECTORS/SUB-COMPONENT-PARAM-CONNECTOR")
+        ]
+        table_row_connectors = [
+            TableRowConnector.from_et(el, doc_frags)
+            for el in et_element.iterfind("TABLE-ROW-CONNECTORS/TABLE-ROW-CONNECTOR")
+        ]
+        env_data_connectors = [
+            EnvDataConnector.from_et(el, doc_frags)
+            for el in et_element.iterfind("ENV-DATA-CONNECTORS/ENV-DATA-CONNECTOR")
+        ]
+        dtc_connectors = [
+            DtcConnector.from_et(el, doc_frags)
+            for el in et_element.iterfind("DTC-CONNECTORS/DTC-CONNECTOR")
+        ]
+
+        return SubComponent(
+            semantic=semantic,
+            sub_component_param_connectors=NamedItemList(sub_component_param_connectors),
+            table_row_connectors=NamedItemList(table_row_connectors),
+            env_data_connectors=NamedItemList(env_data_connectors),
+            dtc_connectors=NamedItemList(dtc_connectors),
+            **kwargs)
+
+    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+        result = {}
+
+        for dtc_conn in self.dtc_connectors:
+            result.update(dtc_conn._build_odxlinks())
+
+        return result
+
+    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
+        for dtc_conn in self.dtc_connectors:
+            dtc_conn._resolve_odxlinks(odxlinks)
+
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
+        for dtc_conn in self.dtc_connectors:
+            dtc_conn._resolve_snrefs(context)

odxtools/swvariable.py

@@ -0,0 +1,21 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass
+from typing import List, Optional
+from xml.etree import ElementTree
+
+from .element import NamedElement
+from .odxlink import OdxDocFragment
+from .utils import dataclass_fields_asdict
+
+
+@dataclass
+class SwVariable(NamedElement):
+    origin: Optional[str]
+
+    @staticmethod
+    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")
+
+        return SwVariable(origin=origin, **kwargs)