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

odxtools/cli/list.py

@@ -4,9 +4,14 @@ from typing import Callable, List, Optional
 
 import rich
 
+from ..comparaminstance import ComparamInstance
 from ..database import Database
+from ..dataobjectproperty import DataObjectProperty
 from ..diagcomm import DiagComm
-from ..diaglayer import DiagLayer
+from ..diaglayers.basevariant import BaseVariant
+from ..diaglayers.diaglayer import DiagLayer
+from ..diaglayers.ecuvariant import EcuVariant
+from ..diaglayers.hierarchyelement import HierarchyElement
 from ..diagservice import DiagService
 from ..singleecujob import SingleEcuJob
 from . import _parser_utils
@@ -47,7 +52,7 @@ def print_summary(odxdb: Database,
     if diag_layers:
         rich.print("\n")
         rich.print(f"Overview of diagnostic layers: ")
-        print_dl_metrics(diag_layers, print_fn=rich.print)
+        print_dl_metrics(diag_layers)
 
     for dl in diag_layers:
         rich.print("\n")
@@ -56,15 +61,14 @@ def print_summary(odxdb: Database,
 
         all_services: List[DiagComm] = sorted(dl.services, key=lambda x: x.short_name)
 
-        data_object_properties = dl.diag_data_dictionary_spec.data_object_props
-        comparams = dl.comparams
+        if isinstance(dl, (BaseVariant, EcuVariant)):
+            for proto in dl.protocols:
+                if (can_rx_id := dl.get_can_receive_id(proto.short_name)) is not None:
+                    rich.print(
+                        f"  CAN receive ID for protocol '{proto.short_name}': 0x{can_rx_id:x}")
 
-        for proto in dl.protocols:
-            if (can_rx_id := dl.get_can_receive_id(proto.short_name)) is not None:
-                rich.print(f"  CAN receive ID for protocol '{proto.short_name}': 0x{can_rx_id:x}")
-
-            if (can_tx_id := dl.get_can_send_id(proto.short_name)) is not None:
-                rich.print(f"  CAN send ID for protocol '{proto.short_name}': 0x{can_tx_id:x}")
+                if (can_tx_id := dl.get_can_send_id(proto.short_name)) is not None:
+                    rich.print(f"  CAN send ID for protocol '{proto.short_name}': 0x{can_tx_id:x}")
 
         if dl.description:
             desc = format_desc(dl.description, indent=2)
@@ -89,13 +93,14 @@ def print_summary(odxdb: Database,
                             print_pre_condition_states=print_pre_condition_states,
                             print_state_transitions=print_state_transitions,
                             print_audiences=print_audiences,
-                            allow_unknown_bit_lengths=allow_unknown_bit_lengths,
-                            print_fn=rich.print)
+                            allow_unknown_bit_lengths=allow_unknown_bit_lengths)
                     elif isinstance(service, SingleEcuJob):
                         rich.print(f" Single ECU job: {service.odx_id}")
                     else:
                         rich.print(f" Unidentifiable service: {service}")
-
+        ddd_spec = dl.diag_data_dictionary_spec
+        data_object_properties: List[
+            DataObjectProperty] = [] if ddd_spec is None else ddd_spec.data_object_props
         if print_dops and len(data_object_properties) > 0:
             rich.print("\n")
             rich.print(f"The DOPs of the {dl.variant_type.value} '{dl.short_name}' are: ")
@@ -103,12 +108,16 @@ def print_summary(odxdb: Database,
                     data_object_properties, key=lambda x: (type(x).__name__, x.short_name)):
                 rich.print("  " + str(dop.short_name).replace("\n", "\n  "))
 
-        if print_comparams and len(comparams) > 0:
+        comparam_refs: List[ComparamInstance] = []
+        if isinstance(dl, HierarchyElement):
+            comparam_refs = dl.comparam_refs
+
+        if print_comparams and len(comparam_refs) > 0:
             rich.print("\n")
             rich.print(
                 f"The communication parameters of the {dl.variant_type.value} '{dl.short_name}' are: "
             )
-            for com_param in comparams:
+            for com_param in comparam_refs:
                 rich.print(f"  {com_param.short_name}: {com_param.value}")
 
 

odxtools/cli/snoop.py

@@ -4,12 +4,13 @@
 import argparse
 import asyncio
 import sys
-from typing import Any, Type
+from typing import Any, List, Optional, Type
 
 import can
 
 import odxtools.isotp_state_machine as ism
 import odxtools.uds as uds
+from odxtools.diaglayers.protocol import Protocol
 from odxtools.exceptions import DecodeError
 from odxtools.isotp_state_machine import IsoTpStateMachine
 from odxtools.response import Response, ResponseType
@@ -245,21 +246,43 @@ def run(args: argparse.Namespace) -> None:
 
     protocol_name = args.protocol
     if odx_diag_layer is not None and protocol_name is not None:
-        protocol_names = [x.short_name for x in odx_diag_layer.protocols]
+        protocols: Optional[List[Protocol]] = getattr(odx_diag_layer, "protocols", None)
+
+        if protocols is None:
+            print(f"ECU variant {odx_diag_layer.short_name} is of type "
+                  f"{odx_diag_layer.variant_type.value} and thus does not "
+                  f"feature any protocols")
+            sys.exit(1)
+
+        protocol_names = [x.short_name for x in protocols]
         if protocol_name not in protocol_names:
             print(f"ECU variant {odx_diag_layer.short_name} does not support "
                   f"a protocol named '{protocol_name}'. Supported protocols are:")
-            for x in odx_diag_layer.protocols:
+            for x in protocols:
                 desc = "" if x.description is None else f": {x.description}"
                 print(f"  {x.short_name}{desc}")
             sys.exit(1)
 
     # if no can IDs have been explicitly specified, take them from the DL
     if args.rx is None and odx_diag_layer:
-        args.rx = str(odx_diag_layer.get_can_receive_id(protocol=protocol_name))
+        get_can_rx_id = getattr(odx_diag_layer, "get_can_receive_id", None)
+        if get_can_rx_id is None:
+            print(f"ECU variant {odx_diag_layer.short_name} is of type "
+                  f"{odx_diag_layer.variant_type.value} and thus does not "
+                  f"provide any communication parameters")
+            sys.exit(1)
+
+        args.rx = str(get_can_rx_id(protocol=protocol_name))
 
     if args.tx is None and odx_diag_layer:
-        args.tx = str(odx_diag_layer.get_can_send_id(protocol=protocol_name))
+        get_can_tx_id = getattr(odx_diag_layer, "get_can_send_id", None)
+        if get_can_tx_id is None:
+            print(f"ECU variant {odx_diag_layer.short_name} is of type "
+                  f"{odx_diag_layer.variant_type.value} and thus does not "
+                  f"provide any communication parameters")
+            sys.exit(1)
+
+        args.tx = str(get_can_tx_id(protocol=protocol_name))
 
     if args.rx is None:
         print(f"Could not determine a CAN receive ID.")

odxtools/codec.py

@@ -0,0 +1,211 @@
+# SPDX-License-Identifier: MIT
+import typing
+from typing import List, Optional, runtime_checkable
+
+from .decodestate import DecodeState
+from .encodestate import EncodeState
+from .exceptions import EncodeError, odxraise
+from .odxtypes import ParameterValue
+from .parameters.codedconstparameter import CodedConstParameter
+from .parameters.matchingrequestparameter import MatchingRequestParameter
+from .parameters.parameter import Parameter
+from .parameters.physicalconstantparameter import PhysicalConstantParameter
+
+
+@runtime_checkable
+class Codec(typing.Protocol):
+    """Any object which can be en- or decoded to be transferred over
+    the wire implements this API.
+    """
+
+    @property
+    def short_name(self) -> str:
+        return ""
+
+    def encode_into_pdu(self, physical_value: Optional[ParameterValue],
+                        encode_state: EncodeState) -> None:
+        ...
+
+    def decode_from_pdu(self, decode_state: DecodeState) -> ParameterValue:
+        ...
+
+    def get_static_bit_length(self) -> Optional[int]:
+        ...
+
+
+@runtime_checkable
+class CompositeCodec(Codec, typing.Protocol):
+    """Any object which can be en- or decoded to be transferred over
+    the wire which is composed of multiple parameter implements this
+    API.
+
+    """
+
+    @property
+    def parameters(self) -> List[Parameter]:
+        return []
+
+    @property
+    def required_parameters(self) -> List[Parameter]:
+        return []
+
+    @property
+    def free_parameters(self) -> List[Parameter]:
+        return []
+
+
+# some helper functions useful for composite codec objects
+def composite_codec_get_static_bit_length(codec: CompositeCodec) -> Optional[int]:
+    """Compute the length of a composite codec object in bits
+
+    This is basically the sum of the lengths of all parameters. If the
+    length of any parameter can only determined at runtime, `None` is
+    returned.
+    """
+
+    cursor = 0
+    byte_length = 0
+    for param in codec.parameters:
+        param_bit_length = param.get_static_bit_length()
+        if param_bit_length is None:
+            # We were not able to calculate a static bit length
+            return None
+        elif param.byte_position is not None:
+            cursor = param.byte_position
+
+        cursor += ((param.bit_position or 0) + param_bit_length + 7) // 8
+        byte_length = max(byte_length, cursor)
+
+    return byte_length * 8
+
+
+def composite_codec_get_required_parameters(codec: CompositeCodec) -> List[Parameter]:
+    """Return the list of parameters which are required to be
+    specified for encoding the composite codec object
+
+    I.e., all free parameters that do not exhibit a default value.
+    """
+    return [p for p in codec.parameters if p.is_required]
+
+
+def composite_codec_get_free_parameters(codec: CompositeCodec) -> List[Parameter]:
+    """Return the list of parameters which can be freely specified by
+    the user when encoding the composite codec object
+
+    This means all required parameters plus parameters that can be
+    omitted because they specify a default.
+    """
+    return [p for p in codec.parameters if p.is_settable]
+
+
+def composite_codec_get_coded_const_prefix(codec: CompositeCodec,
+                                           request_prefix: bytes = b'') -> bytes:
+    encode_state = EncodeState(coded_message=bytearray(), triggering_request=request_prefix)
+
+    for param in codec.parameters:
+        if (isinstance(param, MatchingRequestParameter) and param.request_byte_position < len(request_prefix)) or \
+            isinstance(param, (CodedConstParameter, PhysicalConstantParameter)):
+            param.encode_into_pdu(physical_value=None, encode_state=encode_state)
+        else:
+            break
+
+    return encode_state.coded_message
+
+
+def composite_codec_encode_into_pdu(codec: CompositeCodec, physical_value: Optional[ParameterValue],
+                                    encode_state: EncodeState) -> None:
+    from .parameters.lengthkeyparameter import LengthKeyParameter
+    from .parameters.tablekeyparameter import TableKeyParameter
+
+    if not isinstance(physical_value, dict):
+        odxraise(
+            f"Expected a dictionary for the values of {codec.short_name}, "
+            f"got {type(physical_value).__name__}", EncodeError)
+    elif encode_state.cursor_bit_position != 0:
+        odxraise(
+            f"Compositional codec objecs must be byte aligned, but "
+            f"{codec.short_name} requested to be at bit position "
+            f"{encode_state.cursor_bit_position}", EncodeError)
+        encode_state.bit_position = 0
+
+    orig_origin = encode_state.origin_byte_position
+    encode_state.origin_byte_position = encode_state.cursor_byte_position
+
+    orig_is_end_of_pdu = encode_state.is_end_of_pdu
+    encode_state.is_end_of_pdu = False
+
+    # ensure that no values for unknown parameters are specified.
+    if not encode_state.allow_unknown_parameters:
+        param_names = {param.short_name for param in codec.parameters}
+        for param_value_name in physical_value:
+            if param_value_name not in param_names:
+                odxraise(f"Value for unknown parameter '{param_value_name}' specified "
+                         f"for composite codec object {codec.short_name}")
+
+    for param in codec.parameters:
+        if id(param) == id(codec.parameters[-1]):
+            # The last parameter of the composite codec object is at
+            # the end of the PDU if the codec object itself is at the
+            # end of the PDU.
+            #
+            # TODO: This assumes that the last parameter specified in
+            # the ODX is located last in the PDU...
+            encode_state.is_end_of_pdu = orig_is_end_of_pdu
+
+        if isinstance(param, (LengthKeyParameter, TableKeyParameter)):
+            # At this point, we encode a placeholder value for length-
+            # and table keys, since these can be specified
+            # implicitly (i.e., by means of parameters that use
+            # these keys). To avoid getting an "overlapping
+            # parameter" warning, we must encode a value of zero
+            # into the PDU here and add the real value of the
+            # parameter in a post-processing step.
+            param.encode_placeholder_into_pdu(
+                physical_value=physical_value.get(param.short_name), encode_state=encode_state)
+
+            continue
+
+        if param.is_required and param.short_name not in physical_value:
+            odxraise(f"No value for required parameter {param.short_name} specified", EncodeError)
+
+        param_phys_value = physical_value.get(param.short_name)
+        param.encode_into_pdu(physical_value=param_phys_value, encode_state=encode_state)
+
+        encode_state.journal.append((param, param_phys_value))
+
+    encode_state.is_end_of_pdu = False
+
+    # encode the length- and table keys. This cannot be done above
+    # because we allow these to be defined implicitly (i.e. they
+    # are defined by their respective users)
+    for param in codec.parameters:
+        if not isinstance(param, (LengthKeyParameter, TableKeyParameter)):
+            # the current parameter is neither a length- nor a table key
+            continue
+
+        # Encode the value of the key parameter into the message
+        param.encode_value_into_pdu(encode_state=encode_state)
+
+    encode_state.origin_byte_position = orig_origin
+
+
+def composite_codec_decode_from_pdu(codec: CompositeCodec,
+                                    decode_state: DecodeState) -> ParameterValue:
+    # move the origin since positions specified by sub-parameters of
+    # composite codec objects are relative to the beginning of the
+    # object.
+    orig_origin = decode_state.origin_byte_position
+    decode_state.origin_byte_position = decode_state.cursor_byte_position
+
+    result = {}
+    for param in codec.parameters:
+        value = param.decode_from_pdu(decode_state)
+
+        decode_state.journal.append((param, value))
+        result[param.short_name] = value
+
+    # decoding of the composite codec object finished. go back the
+    # original origin.
+    decode_state.origin_byte_position = orig_origin
+
+    return result

odxtools/commrelation.py

@@ -0,0 +1,122 @@
+# SPDX-License-Identifier: MIT
+import warnings
+from dataclasses import dataclass
+from enum import Enum
+from typing import Any, Dict, List, Optional
+from xml.etree import ElementTree
+
+from .description import Description
+from .diagcomm import DiagComm
+from .diagservice import DiagService
+from .exceptions import OdxWarning, odxraise, odxrequire
+from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef, resolve_snref
+from .parameters.parameter import Parameter
+from .snrefcontext import SnRefContext
+
+
+class CommRelationValueType(Enum):
+    CURRENT = "CURRENT"
+    STORED = "STORED"
+    STATIC = "STATIC"
+    SUBSTITUTED = "SUBSTITUTED"
+
+
+@dataclass
+class CommRelation:
+    description: Optional[Description]
+    relation_type: str
+    diag_comm_ref: Optional[OdxLinkRef]
+    diag_comm_snref: Optional[str]
+    in_param_if_snref: Optional[str]
+    #in_param_if_snpathref: Optional[str] # TODO
+    out_param_if_snref: Optional[str]
+    #out_param_if_snpathref: Optional[str] # TODO
+    value_type_raw: Optional[CommRelationValueType]
+
+    @property
+    def diag_comm(self) -> DiagComm:
+        return self._diag_comm
+
+    @property
+    def in_param_if(self) -> Optional[Parameter]:
+        return self._in_param_if
+
+    @property
+    def out_param_if(self) -> Optional[Parameter]:
+        return self._out_param_if
+
+    @property
+    def value_type(self) -> CommRelationValueType:
+        if self.value_type_raw is None:
+            return CommRelationValueType.CURRENT
+
+        return self.value_type_raw
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "CommRelation":
+        description = Description.from_et(et_element.find("DESC"), doc_frags)
+        relation_type = odxrequire(et_element.findtext("RELATION-TYPE"))
+
+        diag_comm_ref = OdxLinkRef.from_et(et_element.find("DIAG-COMM-REF"), doc_frags)
+        diag_comm_snref = None
+        if (diag_comm_snref_elem := et_element.find("DIAG-COMM-SNREF")) is not None:
+            diag_comm_snref = odxrequire(diag_comm_snref_elem.get("SHORT-NAME"))
+
+        in_param_if_snref = None
+        if (in_param_if_snref_elem := et_element.find("IN-PARAM-IF-SNREF")) is not None:
+            in_param_if_snref = odxrequire(in_param_if_snref_elem.get("SHORT-NAME"))
+
+        if et_element.find("IN-PARAM-IF-SNPATHREF") is not None:
+            warnings.warn("SNPATHREFs are not supported by odxtools yet", OdxWarning, stacklevel=1)
+
+        out_param_if_snref = None
+        if (out_param_if_snref_elem := et_element.find("OUT-PARAM-IF-SNREF")) is not None:
+            out_param_if_snref = odxrequire(out_param_if_snref_elem.get("SHORT-NAME"))
+
+        if et_element.find("OUT-PARAM-IF-SNPATHREF") is not None:
+            warnings.warn("SNPATHREFs are not supported by odxtools yet", OdxWarning, stacklevel=1)
+
+        value_type_raw = None
+        if (value_type_str := et_element.get("VALUE-TYPE")) is not None:
+            try:
+                value_type_raw = CommRelationValueType(value_type_str)
+            except ValueError:
+                odxraise(f"Encountered unknown comm relation value type '{value_type_str}'")
+
+        return CommRelation(
+            description=description,
+            relation_type=relation_type,
+            diag_comm_ref=diag_comm_ref,
+            diag_comm_snref=diag_comm_snref,
+            in_param_if_snref=in_param_if_snref,
+            out_param_if_snref=out_param_if_snref,
+            value_type_raw=value_type_raw)
+
+    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:
+        diag_layer = odxrequire(context.diag_layer)
+
+        if self.diag_comm_snref is not None:
+            self._diag_comm = resolve_snref(self.diag_comm_snref, diag_layer.diag_comms, DiagComm)
+
+        service = self.diag_comm
+        if not isinstance(service, DiagService):
+            odxraise(f"DIAG-VARIABLE references non-service {type(service).__name__} "
+                     f"diagnostic communication")
+
+        self._in_param_if = None
+        if self.in_param_if_snref is not None:
+            self._in_param_if = resolve_snref(self.in_param_if_snref,
+                                              odxrequire(service.request).parameters, Parameter)
+
+        self._out_param_if = None
+        if self.out_param_if_snref is not None:
+            self._out_param_if = resolve_snref(self.out_param_if_snref,
+                                               odxrequire(service.positive_responses[0]).parameters,
+                                               Parameter)

odxtools/companydata.py

@@ -1,6 +1,6 @@
 # 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 .companyspecificinfo import CompanySpecificInfo
@@ -8,12 +8,10 @@ from .element import IdentifiableElement
 from .exceptions import odxrequire
 from .nameditemlist import NamedItemList
 from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
+from .snrefcontext import SnRefContext
 from .teammember import TeamMember
 from .utils import dataclass_fields_asdict
 
-if TYPE_CHECKING:
-    from .diaglayer import DiagLayer
-
 
 @dataclass
 class CompanyData(IdentifiableElement):
@@ -64,9 +62,9 @@ class CompanyData(IdentifiableElement):
         if self.company_specific_info:
             self.company_specific_info._resolve_odxlinks(odxlinks)
 
-    def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
         for tm in self.team_members:
-            tm._resolve_snrefs(diag_layer)
+            tm._resolve_snrefs(context)
 
         if self.company_specific_info:
-            self.company_specific_info._resolve_snrefs(diag_layer)
+            self.company_specific_info._resolve_snrefs(context)

odxtools/companydocinfo.py

@@ -1,18 +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 .companydata import CompanyData
-from .createsdgs import create_sdgs_from_et
 from .exceptions import odxrequire
 from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef
+from .snrefcontext import SnRefContext
 from .specialdatagroup import SpecialDataGroup
 from .teammember import TeamMember
 
-if TYPE_CHECKING:
-    from .diaglayer import DiagLayer
-
 
 @dataclass
 class CompanyDocInfo:
@@ -37,7 +34,9 @@ class CompanyDocInfo:
             OdxLinkRef.from_et(et_element.find("COMPANY-DATA-REF"), doc_frags))
         team_member_ref = OdxLinkRef.from_et(et_element.find("TEAM-MEMBER-REF"), doc_frags)
         doc_label = et_element.findtext("DOC-LABEL")
-        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 CompanyDocInfo(
             company_data_ref=company_data_ref,
@@ -64,6 +63,6 @@ class CompanyDocInfo:
         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/companyrevisioninfo.py

@@ -1,14 +1,12 @@
 # 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 .companydata import CompanyData
 from .exceptions import odxrequire
 from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef
-
-if TYPE_CHECKING:
-    from .diaglayer import DiagLayer
+from .snrefcontext import SnRefContext
 
 
 @dataclass
@@ -39,5 +37,5 @@ class CompanyRevisionInfo:
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
         self._company_data = odxlinks.resolve(self.company_data_ref, CompanyData)
 
-    def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
         pass

odxtools/companyspecificinfo.py

@@ -1,16 +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 .createsdgs import create_sdgs_from_et
 from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
 from .relateddoc import RelatedDoc
+from .snrefcontext import SnRefContext
 from .specialdatagroup import SpecialDataGroup
 
-if TYPE_CHECKING:
-    from .diaglayer import DiagLayer
-
 
 @dataclass
 class CompanySpecificInfo:
@@ -25,7 +22,9 @@ class CompanySpecificInfo:
             for rd in et_element.iterfind("RELATED-DOCS/RELATED-DOC")
         ]
 
-        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 CompanySpecificInfo(related_docs=related_docs, sdgs=sdgs)
 
@@ -44,9 +43,9 @@ class CompanySpecificInfo:
         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 rd in self.related_docs:
-            rd._resolve_snrefs(diag_layer)
+            rd._resolve_snrefs(context)
 
         for sdg in self.sdgs:
-            sdg._resolve_snrefs(diag_layer)
+            sdg._resolve_snrefs(context)

odxtools/comparam.py

@@ -1,17 +1,15 @@
 # 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 .basecomparam import BaseComparam
 from .dataobjectproperty import DataObjectProperty
 from .exceptions import odxrequire
 from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef
+from .snrefcontext import SnRefContext
 from .utils import dataclass_fields_asdict
 
-if TYPE_CHECKING:
-    from .diaglayer import DiagLayer
-
 
 @dataclass
 class Comparam(BaseComparam):
@@ -41,5 +39,5 @@ class Comparam(BaseComparam):
 
         self._dop = odxlinks.resolve(self.dop_ref, DataObjectProperty)
 
-    def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
-        super()._resolve_snrefs(diag_layer)
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
+        super()._resolve_snrefs(context)