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

odxtools/diaglayers/hierarchyelementraw.py

@@ -0,0 +1,58 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass
+from typing import Any, Dict, List
+from xml.etree import ElementTree
+
+from ..comparaminstance import ComparamInstance
+from ..odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
+from ..snrefcontext import SnRefContext
+from ..utils import dataclass_fields_asdict
+from .diaglayerraw import DiagLayerRaw
+
+
+@dataclass
+class HierarchyElementRaw(DiagLayerRaw):
+    """This is the base class for diagnostic layers that may be involved in value inheritance
+
+    This class represents the data present in the XML, not the "logical" view.
+    """
+
+    comparam_refs: List[ComparamInstance]
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element,
+                doc_frags: List[OdxDocFragment]) -> "HierarchyElementRaw":
+        # objects contained by diagnostic layers exibit an additional
+        # document fragment for the diag layer, so we use the document
+        # fragments of the odx id of the diag layer for IDs of
+        # contained objects.
+        dlr = DiagLayerRaw.from_et(et_element, doc_frags)
+        kwargs = dataclass_fields_asdict(dlr)
+        doc_frags = dlr.odx_id.doc_fragments
+
+        comparam_refs = [
+            ComparamInstance.from_et(el, doc_frags)
+            for el in et_element.iterfind("COMPARAM-REFS/COMPARAM-REF")
+        ]
+
+        return HierarchyElementRaw(comparam_refs=comparam_refs, **kwargs)
+
+    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+        result = super()._build_odxlinks()
+
+        for comparam_ref in self.comparam_refs:
+            result.update(comparam_ref._build_odxlinks())
+
+        return result
+
+    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
+        super()._resolve_odxlinks(odxlinks)
+
+        for comparam_ref in self.comparam_refs:
+            comparam_ref._resolve_odxlinks(odxlinks)
+
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
+        super()._resolve_snrefs(context)
+
+        for comparam_ref in self.comparam_refs:
+            comparam_ref._resolve_snrefs(context)

odxtools/diaglayers/protocol.py

@@ -0,0 +1,64 @@
+# SPDX-License-Identifier: MIT
+from copy import deepcopy
+from dataclasses import dataclass
+from typing import Any, Dict, List, Optional, cast
+from xml.etree import ElementTree
+
+from ..comparamspec import ComparamSpec
+from ..exceptions import odxassert
+from ..odxlink import OdxDocFragment
+from ..protstack import ProtStack
+from .hierarchyelement import HierarchyElement
+from .protocolraw import ProtocolRaw
+
+
+@dataclass
+class Protocol(HierarchyElement):
+    """This is the class for primitives that are common for a given communication protocol
+
+    Most importantly this diagnostic layer is responsible for defining
+    the communication parameters that ought to be used.
+    """
+
+    @property
+    def protocol_raw(self) -> ProtocolRaw:
+        return cast(ProtocolRaw, self.diag_layer_raw)
+
+    @property
+    def comparam_spec(self) -> ComparamSpec:
+        return self.protocol_raw.comparam_spec
+
+    @property
+    def prot_stack(self) -> Optional[ProtStack]:
+        return self.protocol_raw.prot_stack
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "Protocol":
+        protocol_raw = ProtocolRaw.from_et(et_element, doc_frags)
+
+        return Protocol(diag_layer_raw=protocol_raw)
+
+    def __post_init__(self) -> None:
+        super().__post_init__()
+
+        odxassert(
+            isinstance(self.diag_layer_raw, ProtocolRaw),
+            "The raw diagnostic layer passed to Protocol "
+            "must be a ProtocolRaw")
+
+    def __deepcopy__(self, memo: Dict[int, Any]) -> Any:
+        """Create a deep copy of the protocol layer
+
+        Note that the copied diagnostic layer is not fully
+        initialized, so `_finalize_init()` should to be called on it
+        before it can be used normally.
+        """
+
+        result = super().__deepcopy__(memo)
+
+        # note that the self.protocol_raw object is *not* copied at
+        # this place because the attribute points to the same object
+        # as self.diag_layer_raw.
+        result.protocol_raw = deepcopy(self.protocol_raw, memo)
+
+        return result

odxtools/diaglayers/protocolraw.py

@@ -0,0 +1,91 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass
+from typing import Any, Dict, List, Optional
+from xml.etree import ElementTree
+
+from ..comparamspec import ComparamSpec
+from ..exceptions import odxrequire
+from ..odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef, resolve_snref
+from ..parentref import ParentRef
+from ..protstack import ProtStack
+from ..snrefcontext import SnRefContext
+from ..utils import dataclass_fields_asdict
+#from .comparaminstance import ComparamInstance
+from .hierarchyelementraw import HierarchyElementRaw
+
+
+@dataclass
+class ProtocolRaw(HierarchyElementRaw):
+    """This is the base class for diagnostic layers that describe a
+    protocol which can be used to communicate with an ECU
+
+    This class represents the data present in the XML, not the "logical" view.
+
+    """
+
+    comparam_spec_ref: OdxLinkRef
+    prot_stack_snref: Optional[str]
+    parent_refs: List[ParentRef]
+
+    @property
+    def comparam_spec(self) -> ComparamSpec:
+        return self._comparam_spec
+
+    @property
+    def prot_stack(self) -> Optional[ProtStack]:
+        return self._prot_stack
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "ProtocolRaw":
+        # objects contained by diagnostic layers exibit an additional
+        # document fragment for the diag layer, so we use the document
+        # fragments of the odx id of the diag layer for IDs of
+        # contained objects.
+        her = HierarchyElementRaw.from_et(et_element, doc_frags)
+        kwargs = dataclass_fields_asdict(her)
+        doc_frags = her.odx_id.doc_fragments
+
+        comparam_spec_ref = OdxLinkRef.from_et(
+            odxrequire(et_element.find("COMPARAM-SPEC-REF")), doc_frags)
+
+        prot_stack_snref = None
+        if (prot_stack_snref_elem := et_element.find("PROT-STACK-SNREF")) is not None:
+            prot_stack_snref = odxrequire(prot_stack_snref_elem.get("SHORT-NAME"))
+
+        parent_refs = [
+            ParentRef.from_et(pr_el, doc_frags)
+            for pr_el in et_element.iterfind("PARENT-REFS/PARENT-REF")
+        ]
+
+        return ProtocolRaw(
+            comparam_spec_ref=comparam_spec_ref,
+            prot_stack_snref=prot_stack_snref,
+            parent_refs=parent_refs,
+            **kwargs)
+
+    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+        result = super()._build_odxlinks()
+
+        for parent_ref in self.parent_refs:
+            result.update(parent_ref._build_odxlinks())
+
+        return result
+
+    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
+        super()._resolve_odxlinks(odxlinks)
+
+        for parent_ref in self.parent_refs:
+            parent_ref._resolve_odxlinks(odxlinks)
+
+        self._comparam_spec = odxlinks.resolve(self.comparam_spec_ref, ComparamSpec)
+
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
+        super()._resolve_snrefs(context)
+
+        self._prot_stack = None
+        if self.prot_stack_snref is not None:
+            self._prot_stack = resolve_snref(self.prot_stack_snref, self._comparam_spec.prot_stacks,
+                                             ProtStack)
+
+        for parent_ref in self.parent_refs:
+            parent_ref._resolve_snrefs(context)

odxtools/diagnostictroublecode.py

@@ -1,26 +1,23 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Dict, List, Optional, Union
+from typing import Any, Dict, List, Optional
 from xml.etree import ElementTree
 
-from .createsdgs import create_sdgs_from_et
 from .element import IdentifiableElement
 from .exceptions import odxrequire
 from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
 from .odxtypes import odxstr_to_bool
+from .snrefcontext import SnRefContext
 from .specialdatagroup import SpecialDataGroup
 from .utils import dataclass_fields_asdict
 
-if TYPE_CHECKING:
-    from .diaglayer import DiagLayer
-
 
 @dataclass
 class DiagnosticTroubleCode(IdentifiableElement):
     trouble_code: int
     text: Optional[str]
     display_trouble_code: Optional[str]
-    level: Union[int, None]
+    level: Optional[int]
     is_temporary_raw: Optional[bool]
     sdgs: List[SpecialDataGroup]
 
@@ -43,7 +40,9 @@ class DiagnosticTroubleCode(IdentifiableElement):
             level = None
 
         is_temporary_raw = odxstr_to_bool(et_element.get("IS-TEMPORARY"))
-        sdgs = create_sdgs_from_et(et_element.find("SDGS"), doc_frags)
+        sdgs = [
+            SpecialDataGroup.from_et(sdge, doc_frags) for sdge in et_element.iterfind("SDGS/SDG")
+        ]
 
         return DiagnosticTroubleCode(
             trouble_code=int(odxrequire(et_element.findtext("TROUBLE-CODE"))),
@@ -69,6 +68,6 @@ class DiagnosticTroubleCode(IdentifiableElement):
         for sdg in self.sdgs:
             sdg._resolve_odxlinks(odxlinks)
 
-    def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
         for sdg in self.sdgs:
-            sdg._resolve_snrefs(diag_layer)
+            sdg._resolve_snrefs(context)

odxtools/diagservice.py

@@ -1,12 +1,12 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
 from enum import Enum
-from typing import TYPE_CHECKING, Any, Dict, List, Optional, Union, cast
+from typing import Any, Dict, List, Optional, Union, cast
 from xml.etree import ElementTree
 
 from .comparaminstance import ComparamInstance
 from .diagcomm import DiagComm
-from .exceptions import DecodeError, odxassert, odxraise, odxrequire
+from .exceptions import DecodeError, DecodeMismatch, odxassert, odxraise, odxrequire
 from .message import Message
 from .nameditemlist import NamedItemList
 from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef
@@ -14,11 +14,9 @@ from .odxtypes import ParameterValue, odxstr_to_bool
 from .parameters.parameter import Parameter
 from .request import Request
 from .response import Response
+from .snrefcontext import SnRefContext
 from .utils import dataclass_fields_asdict
 
-if TYPE_CHECKING:
-    from .diaglayer import DiagLayer
-
 
 class Addressing(Enum):
     FUNCTIONAL = "FUNCTIONAL"
@@ -44,7 +42,9 @@ class DiagService(DiagComm):
     pos_response_refs: List[OdxLinkRef]
     neg_response_refs: List[OdxLinkRef]
 
-    # TODO: pos_response_suppressable: Optional[PosResponseSuppressable]
+    # note that the spec has a typo here: it calls the corresponding
+    # XML tag POS-RESPONSE-SUPPRESSABLE...
+    # TODO: pos_response_suppressible: Optional[PosResponseSuppressible]
 
     is_cyclic_raw: Optional[bool]
     is_multiple_raw: Optional[bool]
@@ -167,7 +167,7 @@ class DiagService(DiagComm):
         for cpr in self.comparam_refs:
             cpr._resolve_odxlinks(odxlinks)
 
-        self._request = odxlinks.resolve(self.request_ref)
+        self._request = odxlinks.resolve(self.request_ref, Request)
 
         self._positive_responses = NamedItemList[Response](
             [odxlinks.resolve(x, Response) for x in self.pos_response_refs])
@@ -175,16 +175,21 @@ class DiagService(DiagComm):
         self._negative_responses = NamedItemList[Response](
             [odxlinks.resolve(x, Response) for x in self.neg_response_refs])
 
-    def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
-        super()._resolve_snrefs(diag_layer)
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
+        context.diag_service = self
+
+        super()._resolve_snrefs(context)
 
         for cpr in self.comparam_refs:
-            cpr._resolve_snrefs(diag_layer)
+            cpr._resolve_snrefs(context)
 
-        # comparams named list is lazy loaded
-        # since ComparamInstance short_name is only valid after resolution
+        # The named item list of communication parameters is created
+        # here because ComparamInstance.short_name is only valid after
+        # reference resolution
         self._comparams = NamedItemList(self.comparam_refs)
 
+        context.diag_service = None
+
     def decode_message(self, raw_message: bytes) -> Message:
         request_prefix = b''
         candidate_coding_objects: List[Union[Request, Response]] = [
@@ -200,28 +205,36 @@ class DiagService(DiagComm):
             if len(raw_message) >= len(prefix) and prefix == raw_message[:len(prefix)]:
                 coding_objects.append(candidate_coding_object)
 
-        if len(coding_objects) != 1:
-            raise DecodeError(
-                f"The service {self.short_name} cannot decode the message {raw_message.hex()}")
-        coding_object = coding_objects[0]
-        param_dict = coding_object.decode(raw_message)
-        if not isinstance(param_dict, dict):
-            # if this happens, this is probably due to a bug in
-            # coding_object.decode()
-            raise RuntimeError(f"Expected a set of decoded parameters, got {type(param_dict)}")
-        return Message(
-            coded_message=raw_message,
-            service=self,
-            coding_object=coding_object,
-            param_dict=param_dict)
-
-    def encode_request(self, **params: ParameterValue) -> bytes:
-        """
-        Composes an UDS request as list of bytes for this service.
-        Parameters:
-        ----------
-        params: dict
-            Parameters of the RPC as mapping from SHORT-NAME of the parameter to the physical value
+        result_list: List[Message] = []
+        for coding_object in coding_objects:
+            try:
+                result_list.append(
+                    Message(
+                        coded_message=raw_message,
+                        service=self,
+                        coding_object=coding_object,
+                        param_dict=coding_object.decode(raw_message)))
+            except DecodeMismatch:
+                # An NRC-CONST or environment data parameter
+                # encountered a non-matching value -> coding object
+                # does not apply
+                pass
+
+        if len(result_list) < 1:
+            odxraise(f"The service {self.short_name} cannot decode the message {raw_message.hex()}",
+                     DecodeError)
+            return Message(
+                coded_message=raw_message, service=self, coding_object=None, param_dict={})
+        elif len(result_list) > 1:
+            odxraise(
+                f"The service {self.short_name} cannot uniquely decode the message {raw_message.hex()}",
+                DecodeError)
+
+        return result_list[0]
+
+    def encode_request(self, **kwargs: ParameterValue) -> bytes:
+        """Prepare an array of bytes ready to be send over the wire
+        for the request of this service.
         """
         # make sure that all parameters which are required for
         # encoding are specified (parameters which have a default are
@@ -230,31 +243,31 @@ class DiagService(DiagComm):
             return b''
 
         missing_params = {x.short_name
-                          for x in self.request.required_parameters}.difference(params.keys())
+                          for x in self.request.required_parameters}.difference(kwargs.keys())
         odxassert(
             len(missing_params) == 0, f"The parameters {missing_params} are required but missing!")
 
         # make sure that no unknown parameters are specified
         rq_all_param_names = {x.short_name for x in self.request.parameters}
         odxassert(
-            set(params.keys()).issubset(rq_all_param_names),
-            f"Unknown parameters specified for encoding: {params.keys()}, "
+            set(kwargs.keys()).issubset(rq_all_param_names),
+            f"Unknown parameters specified for encoding: {kwargs.keys()}, "
             f"known parameters are: {rq_all_param_names}")
-        return self.request.encode(coded_request=None, **params)
+        return self.request.encode(**kwargs)
 
     def encode_positive_response(self,
                                  coded_request: bytes,
                                  response_index: int = 0,
-                                 **params: ParameterValue) -> bytes:
+                                 **kwargs: ParameterValue) -> bytes:
         # TODO: Should the user decide the positive response or what are the differences?
-        return self.positive_responses[response_index].encode(coded_request, **params)
+        return self.positive_responses[response_index].encode(coded_request, **kwargs)
 
     def encode_negative_response(self,
                                  coded_request: bytes,
                                  response_index: int = 0,
-                                 **params: ParameterValue) -> bytes:
-        return self.negative_responses[response_index].encode(coded_request, **params)
+                                 **kwargs: ParameterValue) -> bytes:
+        return self.negative_responses[response_index].encode(coded_request, **kwargs)
 
-    def __call__(self, **params: ParameterValue) -> bytes:
+    def __call__(self, **kwargs: ParameterValue) -> bytes:
         """Encode a request."""
-        return self.encode_request(**params)
+        return self.encode_request(**kwargs)

odxtools/diagvariable.py

@@ -0,0 +1,113 @@
+# SPDX-License-Identifier: MIT
+import typing
+from dataclasses import dataclass
+from typing import Any, Dict, List, Optional, runtime_checkable
+from xml.etree import ElementTree
+
+from .admindata import AdminData
+from .commrelation import CommRelation
+from .element import IdentifiableElement
+from .exceptions import odxrequire
+from .nameditemlist import NamedItemList
+from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef
+from .odxtypes import odxstr_to_bool
+from .snrefcontext import SnRefContext
+from .specialdatagroup import SpecialDataGroup
+from .swvariable import SwVariable
+from .utils import dataclass_fields_asdict
+from .variablegroup import VariableGroup
+
+
+@runtime_checkable
+class HasDiagVariables(typing.Protocol):
+
+    @property
+    def diag_variables(self) -> "NamedItemList[DiagVariable]":
+        ...
+
+
+@dataclass
+class DiagVariable(IdentifiableElement):
+    """Representation of a diagnostic variable
+    """
+
+    admin_data: Optional[AdminData]
+    variable_group_ref: OdxLinkRef
+    sw_variables: List[SwVariable]
+    comm_relations: List[CommRelation]
+    #snref_to_tablerow: Optional[SnrefToTableRow] # TODO
+    sdgs: List[SpecialDataGroup]
+    is_read_before_write_raw: Optional[bool]
+
+    @property
+    def variable_group(self) -> VariableGroup:
+        return self._variable_group
+
+    @property
+    def is_read_before_write(self) -> bool:
+        return self.is_read_before_write_raw is True
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "DiagVariable":
+        kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, doc_frags))
+
+        admin_data = AdminData.from_et(et_element.find("ADMIN-DATA"), doc_frags)
+        variable_group_ref = odxrequire(
+            OdxLinkRef.from_et(et_element.find("VARIABLE-GROUP-REF"), doc_frags))
+        sw_variables = NamedItemList([
+            SwVariable.from_et(swv_elem, doc_frags)
+            for swv_elem in et_element.iterfind("SW-VARIABLES/SW-VARIABLE")
+        ])
+        comm_relations = [
+            CommRelation.from_et(cr_elem, doc_frags)
+            for cr_elem in et_element.iterfind("COMM-RELATIONS/COMM-RELATION")
+        ]
+        sdgs = [
+            SpecialDataGroup.from_et(sdge, doc_frags) for sdge in et_element.iterfind("SDGS/SDG")
+        ]
+        is_read_before_write_raw = odxstr_to_bool(et_element.get("IS-READ-BEFORE-WRITE"))
+
+        return DiagVariable(
+            admin_data=admin_data,
+            variable_group_ref=variable_group_ref,
+            sw_variables=sw_variables,
+            comm_relations=comm_relations,
+            sdgs=sdgs,
+            is_read_before_write_raw=is_read_before_write_raw,
+            **kwargs)
+
+    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+        result = {self.odx_id: self}
+
+        if self.admin_data is not None:
+            result.update(self.admin_data._build_odxlinks())
+
+        for sdg in self.sdgs:
+            result.update(sdg._build_odxlinks())
+
+        for cr in self.comm_relations:
+            result.update(cr._build_odxlinks())
+
+        return result
+
+    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
+        self._variable_group = odxlinks.resolve(self.variable_group_ref, VariableGroup)
+
+        if self.admin_data is not None:
+            self.admin_data._resolve_odxlinks(odxlinks)
+
+        for sdg in self.sdgs:
+            sdg._resolve_odxlinks(odxlinks)
+
+        for cr in self.comm_relations:
+            cr._resolve_odxlinks(odxlinks)
+
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
+        if self.admin_data is not None:
+            self.admin_data._resolve_snrefs(context)
+
+        for sdg in self.sdgs:
+            sdg._resolve_snrefs(context)
+
+        for cr in self.comm_relations:
+            cr._resolve_snrefs(context)

odxtools/docrevision.py

@@ -1,17 +1,15 @@
 # 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 .companyrevisioninfo import CompanyRevisionInfo
 from .exceptions import odxrequire
 from .modification import Modification
 from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef
+from .snrefcontext import SnRefContext
 from .teammember import TeamMember
 
-if TYPE_CHECKING:
-    from .diaglayer import DiagLayer
-
 
 @dataclass
 class DocRevision:
@@ -75,9 +73,9 @@ class DocRevision:
         for mod in self.modifications:
             mod._resolve_odxlinks(odxlinks)
 
-    def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
         for cri in self.company_revision_infos:
-            cri._resolve_snrefs(diag_layer)
+            cri._resolve_snrefs(context)
 
         for mod in self.modifications:
-            mod._resolve_snrefs(diag_layer)
+            mod._resolve_snrefs(context)

odxtools/dopbase.py

@@ -1,27 +1,27 @@
 # 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 .admindata import AdminData
-from .createsdgs import create_sdgs_from_et
 from .decodestate import DecodeState
 from .element import IdentifiableElement
 from .encodestate import EncodeState
 from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
 from .odxtypes import ParameterValue
+from .snrefcontext import SnRefContext
 from .specialdatagroup import SpecialDataGroup
 from .utils import dataclass_fields_asdict
 
-if TYPE_CHECKING:
-    from .diaglayer import DiagLayer
-
 
 @dataclass
 class DopBase(IdentifiableElement):
-    """Base class for all DOPs.
+    """Base class for all (simple and complex) data object properties.
+
+    Any class that a parameter can reference via a DOP-REF (Simple
+    DOPs, structures, ...) inherits from this class. All DOPs objects
+    implement the `Codec` type protocol.
 
-    Any class that a parameter can reference via a DOP-REF should inherit from this class.
     """
 
     admin_data: Optional[AdminData]
@@ -36,7 +36,9 @@ class DopBase(IdentifiableElement):
         if (admin_data_elem := et_element.find("ADMIN-DATA")) is not None:
             admin_data = AdminData.from_et(admin_data_elem, doc_frags)
 
-        sdgs = create_sdgs_from_et(et_element.find("SDGS"), doc_frags)
+        sdgs = [
+            SpecialDataGroup.from_et(sdge, doc_frags) for sdge in et_element.iterfind("SDGS/SDG")
+        ]
 
         return DopBase(admin_data=admin_data, sdgs=sdgs, **kwargs)
 
@@ -52,21 +54,19 @@ class DopBase(IdentifiableElement):
         for sdg in self.sdgs:
             sdg._resolve_odxlinks(odxlinks)
 
-    def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
         for sdg in self.sdgs:
-            sdg._resolve_snrefs(diag_layer)
+            sdg._resolve_snrefs(context)
 
     def get_static_bit_length(self) -> Optional[int]:
         return None
 
     def is_valid_physical_value(self, physical_value: ParameterValue) -> bool:
-        """Determine if a phyical value can be handled by the DOP
-        """
+        """Determine if a phyical value can be handled by the DOP"""
         raise NotImplementedError
 
-    def convert_physical_to_bytes(self, physical_value: ParameterValue, encode_state: EncodeState,
-                                  bit_position: int) -> bytes:
-        """Convert the physical value into bytes."""
+    def encode_into_pdu(self, physical_value: ParameterValue, encode_state: EncodeState) -> None:
+        """Convert the physical value to bytes and emplace them into a PDU."""
         raise NotImplementedError
 
     def decode_from_pdu(self, decode_state: DecodeState) -> ParameterValue: