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

odxtools/{diaglayerraw.py → diaglayers/diaglayerraw.py}

@@ -1,36 +1,30 @@
 # SPDX-License-Identifier: MIT
 from copy import copy
 from dataclasses import dataclass
-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 .additionalaudience import AdditionalAudience
-from .admindata import AdminData
-from .companydata import CompanyData
-from .comparaminstance import ComparamInstance
-from .comparamspec import ComparamSpec
-from .createsdgs import create_sdgs_from_et
-from .diagcomm import DiagComm
-from .diagdatadictionaryspec import DiagDataDictionarySpec
+from ..additionalaudience import AdditionalAudience
+from ..admindata import AdminData
+from ..companydata import CompanyData
+from ..diagcomm import DiagComm
+from ..diagdatadictionaryspec import DiagDataDictionarySpec
+from ..diagservice import DiagService
+from ..element import IdentifiableElement
+from ..exceptions import odxassert, odxraise, odxrequire
+from ..functionalclass import FunctionalClass
+from ..library import Library
+from ..nameditemlist import NamedItemList
+from ..odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef
+from ..request import Request
+from ..response import Response
+from ..singleecujob import SingleEcuJob
+from ..snrefcontext import SnRefContext
+from ..specialdatagroup import SpecialDataGroup
+from ..statechart import StateChart
+from ..subcomponent import SubComponent
+from ..utils import dataclass_fields_asdict
 from .diaglayertype import DiagLayerType
-from .diagservice import DiagService
-from .ecuvariantpattern import EcuVariantPattern
-from .element import IdentifiableElement
-from .exceptions import odxassert, odxraise, odxrequire
-from .functionalclass import FunctionalClass
-from .nameditemlist import NamedItemList
-from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef
-from .parentref import ParentRef
-from .protstack import ProtStack
-from .request import Request
-from .response import Response
-from .singleecujob import SingleEcuJob
-from .specialdatagroup import SpecialDataGroup
-from .statechart import StateChart
-from .utils import dataclass_fields_asdict
-
-if TYPE_CHECKING:
-    from .diaglayer import DiagLayer
 
 
 @dataclass
@@ -46,7 +40,7 @@ class DiagLayerRaw(IdentifiableElement):
     company_datas: NamedItemList[CompanyData]
     functional_classes: NamedItemList[FunctionalClass]
     diag_data_dictionary_spec: Optional[DiagDataDictionarySpec]
-    diag_comms: List[Union[OdxLinkRef, DiagComm]]
+    diag_comms_raw: List[Union[OdxLinkRef, DiagComm]]
     requests: NamedItemList[Request]
     positive_responses: NamedItemList[Response]
     negative_responses: NamedItemList[Response]
@@ -54,21 +48,26 @@ class DiagLayerRaw(IdentifiableElement):
     import_refs: List[OdxLinkRef]
     state_charts: NamedItemList[StateChart]
     additional_audiences: NamedItemList[AdditionalAudience]
-    # sub_components: List[DiagLayer] # TODO
-    # libraries: List[DiagLayer] # TODO
+    sub_components: NamedItemList[SubComponent]
+    libraries: NamedItemList[Library]
     sdgs: List[SpecialDataGroup]
 
-    # these attributes are only defined for some kinds of diag layers!
-    # TODO: make a proper class hierarchy!
-    parent_refs: List[ParentRef]
-    comparams: List[ComparamInstance]
-    ecu_variant_patterns: List[EcuVariantPattern]
-    comparam_spec_ref: Optional[OdxLinkRef]
-    prot_stack_snref: Optional[str]
-    # diag_variables: List[DiagVariable] # TODO
-    # diag_variable_groups: List[DiagVariableGroup] # TODO
-    # dyn_defined_spec: Optional[DynDefinedSpec] # TODO
-    # base_variant_patterns: List[EcuVariantPattern] # TODO
+    @property
+    def diag_comms(self) -> NamedItemList[DiagComm]:
+        return self._diag_comms
+
+    @property
+    def diag_services(self) -> NamedItemList[DiagService]:
+        return self._diag_services
+
+    @property
+    def services(self) -> NamedItemList[DiagService]:
+        """This property is an alias for `.diag_services`"""
+        return self._diag_services
+
+    @property
+    def single_ecu_jobs(self) -> NamedItemList[SingleEcuJob]:
+        return self._single_ecu_jobs
 
     @staticmethod
     def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "DiagLayerRaw":
@@ -103,7 +102,7 @@ class DiagLayerRaw(IdentifiableElement):
         if (ddds_elem := et_element.find("DIAG-DATA-DICTIONARY-SPEC")) is not None:
             diag_data_dictionary_spec = DiagDataDictionarySpec.from_et(ddds_elem, doc_frags)
 
-        diag_comms: List[Union[OdxLinkRef, DiagComm]] = []
+        diag_comms_raw: List[Union[OdxLinkRef, DiagComm]] = []
         if (dc_elems := et_element.find("DIAG-COMMS")) is not None:
             for dc_proxy_elem in dc_elems:
                 dc: Union[OdxLinkRef, DiagComm]
@@ -115,7 +114,7 @@ class DiagLayerRaw(IdentifiableElement):
                     odxassert(dc_proxy_elem.tag == "SINGLE-ECU-JOB")
                     dc = SingleEcuJob.from_et(dc_proxy_elem, doc_frags)
 
-                diag_comms.append(dc)
+                diag_comms_raw.append(dc)
 
         requests = NamedItemList([
             Request.from_et(rq_elem, doc_frags)
@@ -152,31 +151,18 @@ class DiagLayerRaw(IdentifiableElement):
             for el in et_element.iterfind("ADDITIONAL-AUDIENCES/ADDITIONAL-AUDIENCE")
         ]
 
-        sdgs = create_sdgs_from_et(et_element.find("SDGS"), doc_frags)
-
-        parent_refs = [
-            ParentRef.from_et(pr_el, doc_frags)
-            for pr_el in et_element.iterfind("PARENT-REFS/PARENT-REF")
+        libraries = [
+            Library.from_et(el, doc_frags) for el in et_element.iterfind("LIBRARYS/LIBRARY")
         ]
 
-        comparams = [
-            ComparamInstance.from_et(el, doc_frags)
-            for el in et_element.iterfind("COMPARAM-REFS/COMPARAM-REF")
+        sub_components = [
+            SubComponent.from_et(el, doc_frags)
+            for el in et_element.iterfind("SUB-COMPONENTS/SUB-COMPONENT")
         ]
 
-        ecu_variant_patterns = [
-            EcuVariantPattern.from_et(el, doc_frags)
-            for el in et_element.iterfind("ECU-VARIANT-PATTERNS/ECU-VARIANT-PATTERN")
+        sdgs = [
+            SpecialDataGroup.from_et(sdge, doc_frags) for sdge in et_element.iterfind("SDGS/SDG")
         ]
-        if variant_type is not DiagLayerType.ECU_VARIANT:
-            odxassert(
-                len(ecu_variant_patterns) == 0,
-                "DiagLayer of type other than 'ECU-VARIANT' must not define a ECU-VARIANT-PATTERN")
-
-        comparam_spec_ref = OdxLinkRef.from_et(et_element.find("COMPARAM-SPEC-REF"), doc_frags)
-        prot_stack_snref: Optional[str] = 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"))
 
         # Create DiagLayer
         return DiagLayerRaw(
@@ -185,7 +171,7 @@ class DiagLayerRaw(IdentifiableElement):
             company_datas=NamedItemList(company_datas),
             functional_classes=NamedItemList(functional_classes),
             diag_data_dictionary_spec=diag_data_dictionary_spec,
-            diag_comms=diag_comms,
+            diag_comms_raw=diag_comms_raw,
             requests=requests,
             positive_responses=positive_responses,
             negative_responses=negative_responses,
@@ -193,12 +179,9 @@ class DiagLayerRaw(IdentifiableElement):
             import_refs=import_refs,
             state_charts=NamedItemList(state_charts),
             additional_audiences=NamedItemList(additional_audiences),
+            libraries=NamedItemList(libraries),
+            sub_components=NamedItemList(sub_components),
             sdgs=sdgs,
-            parent_refs=parent_refs,
-            comparams=comparams,
-            ecu_variant_patterns=ecu_variant_patterns,
-            comparam_spec_ref=comparam_spec_ref,
-            prot_stack_snref=prot_stack_snref,
             **kwargs)
 
     def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
@@ -214,10 +197,10 @@ class DiagLayerRaw(IdentifiableElement):
             odxlinks.update(company_data._build_odxlinks())
         for functional_class in self.functional_classes:
             odxlinks.update(functional_class._build_odxlinks())
-        for diag_comm in self.diag_comms:
-            if isinstance(diag_comm, OdxLinkRef):
+        for dc_proxy in self.diag_comms_raw:
+            if isinstance(dc_proxy, OdxLinkRef):
                 continue
-            odxlinks.update(diag_comm._build_odxlinks())
+            odxlinks.update(dc_proxy._build_odxlinks())
         for request in self.requests:
             odxlinks.update(request._build_odxlinks())
         for positive_response in self.positive_responses:
@@ -230,21 +213,18 @@ class DiagLayerRaw(IdentifiableElement):
             odxlinks.update(state_chart._build_odxlinks())
         for additional_audience in self.additional_audiences:
             odxlinks.update(additional_audience._build_odxlinks())
+        for library in self.libraries:
+            odxlinks.update(library._build_odxlinks())
+        for sub_comp in self.sub_components:
+            odxlinks.update(sub_comp._build_odxlinks())
         for sdg in self.sdgs:
             odxlinks.update(sdg._build_odxlinks())
-        for parent_ref in self.parent_refs:
-            odxlinks.update(parent_ref._build_odxlinks())
-        for comparam in self.comparams:
-            odxlinks.update(comparam._build_odxlinks())
 
         return odxlinks
 
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
         """Recursively resolve all references."""
 
-        if self.comparam_spec_ref is not None:
-            self._comparam_spec = odxlinks.resolve(self.comparam_spec_ref, ComparamSpec)
-
         # do ODXLINK reference resolution
         if self.admin_data is not None:
             self.admin_data._resolve_odxlinks(odxlinks)
@@ -255,10 +235,28 @@ class DiagLayerRaw(IdentifiableElement):
             company_data._resolve_odxlinks(odxlinks)
         for functional_class in self.functional_classes:
             functional_class._resolve_odxlinks(odxlinks)
-        for diag_comm in self.diag_comms:
-            if isinstance(diag_comm, OdxLinkRef):
-                continue
-            diag_comm._resolve_odxlinks(odxlinks)
+
+        # resolve references to diagnostic communication objects and
+        # separate them into services and single-ecu jobs
+        self._diag_comms = NamedItemList[DiagComm]()
+        self._diag_services = NamedItemList[DiagService]()
+        self._single_ecu_jobs = NamedItemList[SingleEcuJob]()
+        for dc_proxy in self.diag_comms_raw:
+            if isinstance(dc_proxy, OdxLinkRef):
+                dc = odxlinks.resolve(dc_proxy, DiagComm)
+            else:
+                dc = dc_proxy
+                dc._resolve_odxlinks(odxlinks)
+
+            self._diag_comms.append(dc)
+
+            if isinstance(dc, DiagService):
+                self._diag_services.append(dc)
+            elif isinstance(dc, SingleEcuJob):
+                self._single_ecu_jobs.append(dc)
+            else:
+                odxraise()
+
         for request in self.requests:
             request._resolve_odxlinks(odxlinks)
         for positive_response in self.positive_responses:
@@ -271,56 +269,43 @@ class DiagLayerRaw(IdentifiableElement):
             state_chart._resolve_odxlinks(odxlinks)
         for additional_audience in self.additional_audiences:
             additional_audience._resolve_odxlinks(odxlinks)
+        for library in self.libraries:
+            library._resolve_odxlinks(odxlinks)
+        for sub_component in self.sub_components:
+            sub_component._resolve_odxlinks(odxlinks)
         for sdg in self.sdgs:
             sdg._resolve_odxlinks(odxlinks)
-        for parent_ref in self.parent_refs:
-            parent_ref._resolve_odxlinks(odxlinks)
-        for comparam in self.comparams:
-            comparam._resolve_odxlinks(odxlinks)
-
-    def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
-        self._prot_stack: Optional[ProtStack] = None
-        if self.prot_stack_snref is not None:
-            self._prot_stack = odxrequire(
-                odxrequire(self.comparam_spec).prot_stacks.get(self.prot_stack_snref))
 
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
         # do short-name reference resolution
         if self.admin_data is not None:
-            self.admin_data._resolve_snrefs(diag_layer)
+            self.admin_data._resolve_snrefs(context)
         if self.diag_data_dictionary_spec is not None:
-            self.diag_data_dictionary_spec._resolve_snrefs(diag_layer)
+            self.diag_data_dictionary_spec._resolve_snrefs(context)
 
         for company_data in self.company_datas:
-            company_data._resolve_snrefs(diag_layer)
-        for functional_classe in self.functional_classes:
-            functional_classe._resolve_snrefs(diag_layer)
-        for diag_comm in self.diag_comms:
-            if isinstance(diag_comm, OdxLinkRef):
+            company_data._resolve_snrefs(context)
+        for functional_class in self.functional_classes:
+            functional_class._resolve_snrefs(context)
+        for dc_proxy in self.diag_comms_raw:
+            if isinstance(dc_proxy, OdxLinkRef):
                 continue
-            diag_comm._resolve_snrefs(diag_layer)
+            dc_proxy._resolve_snrefs(context)
         for request in self.requests:
-            request._resolve_snrefs(diag_layer)
+            request._resolve_snrefs(context)
         for positive_response in self.positive_responses:
-            positive_response._resolve_snrefs(diag_layer)
+            positive_response._resolve_snrefs(context)
         for negative_response in self.negative_responses:
-            negative_response._resolve_snrefs(diag_layer)
+            negative_response._resolve_snrefs(context)
         for global_negative_response in self.global_negative_responses:
-            global_negative_response._resolve_snrefs(diag_layer)
+            global_negative_response._resolve_snrefs(context)
         for state_chart in self.state_charts:
-            state_chart._resolve_snrefs(diag_layer)
+            state_chart._resolve_snrefs(context)
         for additional_audience in self.additional_audiences:
-            additional_audience._resolve_snrefs(diag_layer)
+            additional_audience._resolve_snrefs(context)
+        for library in self.libraries:
+            library._resolve_snrefs(context)
+        for sub_component in self.sub_components:
+            sub_component._resolve_snrefs(context)
         for sdg in self.sdgs:
-            sdg._resolve_snrefs(diag_layer)
-        for parent_ref in self.parent_refs:
-            parent_ref._resolve_snrefs(diag_layer)
-        for comparam in self.comparams:
-            comparam._resolve_snrefs(diag_layer)
-
-    @property
-    def comparam_spec(self) -> Optional[ComparamSpec]:
-        return self._comparam_spec
-
-    @property
-    def prot_stack(self) -> Optional[ProtStack]:
-        return self._prot_stack
+            sdg._resolve_snrefs(context)

odxtools/diaglayers/diaglayertype.py

@@ -0,0 +1,42 @@
+# SPDX-License-Identifier: MIT
+from enum import Enum
+from typing import Dict
+
+
+class DiagLayerType(Enum):
+    PROTOCOL = "PROTOCOL"
+    FUNCTIONAL_GROUP = "FUNCTIONAL-GROUP"
+    BASE_VARIANT = "BASE-VARIANT"
+    ECU_VARIANT = "ECU-VARIANT"
+    ECU_SHARED_DATA = "ECU-SHARED-DATA"
+
+    @property
+    def inheritance_priority(self) -> int:
+        """Return the inheritance priority of diag layers of the given type
+
+        ODX mandates that diagnostic layers can only inherit from
+        layers of lower priority...
+
+        """
+
+        PRIORITY_OF_DIAG_LAYER_TYPE: Dict[DiagLayerType, int] = {
+            DiagLayerType.PROTOCOL:
+                1,
+            DiagLayerType.FUNCTIONAL_GROUP:
+                2,
+            DiagLayerType.BASE_VARIANT:
+                3,
+            DiagLayerType.ECU_VARIANT:
+                4,
+
+            # ECU shared data layers are a bit weird (see section
+            # 7.3.2.4.4 of the ASAM specification): they can be
+            # inherited from by any other layer but they will
+            # override any objects which are also provided by any of
+            # the other parent layers. tl;dr: When it comes to
+            # inheritance, they have the highest priority.
+            DiagLayerType.ECU_SHARED_DATA:
+                100,
+        }
+
+        return PRIORITY_OF_DIAG_LAYER_TYPE[self]

odxtools/diaglayers/ecushareddata.py

@@ -0,0 +1,96 @@
+# SPDX-License-Identifier: MIT
+from copy import deepcopy
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any, Dict, List, Union, cast
+from xml.etree import ElementTree
+
+from ..diagvariable import DiagVariable
+from ..exceptions import odxassert
+from ..nameditemlist import NamedItemList
+from ..odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkRef
+from ..snrefcontext import SnRefContext
+from ..variablegroup import VariableGroup
+from .diaglayer import DiagLayer
+from .ecushareddataraw import EcuSharedDataRaw
+
+if TYPE_CHECKING:
+    from .database import Database
+
+
+@dataclass
+class EcuSharedData(DiagLayer):
+    """This is a diagnostic layer for data shared across others
+    """
+
+    @property
+    def ecu_shared_data_raw(self) -> EcuSharedDataRaw:
+        return cast(EcuSharedDataRaw, self.diag_layer_raw)
+
+    @property
+    def diag_variables_raw(self) -> List[Union[OdxLinkRef, DiagVariable]]:
+        return self.ecu_shared_data_raw.diag_variables_raw
+
+    @property
+    def diag_variables(self) -> NamedItemList[DiagVariable]:
+        return self.ecu_shared_data_raw.diag_variables
+
+    @property
+    def variable_groups(self) -> NamedItemList[VariableGroup]:
+        return self.ecu_shared_data_raw.variable_groups
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element,
+                doc_frags: List[OdxDocFragment]) -> "EcuSharedData":
+        ecu_shared_data_raw = EcuSharedDataRaw.from_et(et_element, doc_frags)
+
+        return EcuSharedData(diag_layer_raw=ecu_shared_data_raw)
+
+    def __post_init__(self) -> None:
+        super().__post_init__()
+
+        odxassert(
+            isinstance(self.diag_layer_raw, EcuSharedDataRaw),
+            "The raw diagnostic layer passed to EcuSharedData "
+            "must be a EcuSharedDataRaw")
+
+    def _finalize_init(self, database: "Database", odxlinks: OdxLinkDatabase) -> None:
+        """This method makes sure that all references in sub-objects
+        of the ECU shared data layer are resolved
+
+        In contrast to hierarchy element layers, ECU shared data
+        layers do not need to deal with inheritance...
+
+        """
+
+        # this attribute may be removed later. it is currently
+        # required to properly deal with auxiliary files within the
+        # diagnostic layer.
+        self._database = database
+
+        #####
+        # resolve all SNREFs. TODO: We allow SNREFS to objects that
+        # were inherited by the diaglayer. This might not be allowed
+        # by the spec (So far, I haven't found any definitive
+        # statement...)
+        #####
+        context = SnRefContext(database=database)
+        context.diag_layer = self
+        self._resolve_snrefs(context)
+        context.diag_layer = None
+
+    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.ecu_shared_data_raw object is *not* copied at
+        # this place because the attribute points to the same object
+        # as self.diag_layer_raw.
+        result.ecu_shared_data_raw = deepcopy(self.ecu_shared_data_raw, memo)
+
+        return result

odxtools/diaglayers/ecushareddataraw.py

@@ -0,0 +1,87 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass
+from typing import Any, Dict, List, Union
+from xml.etree import ElementTree
+
+from ..diagvariable import DiagVariable
+from ..exceptions import odxraise
+from ..nameditemlist import NamedItemList
+from ..odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef
+from ..snrefcontext import SnRefContext
+from ..utils import dataclass_fields_asdict
+from ..variablegroup import VariableGroup
+from .diaglayerraw import DiagLayerRaw
+
+
+@dataclass
+class EcuSharedDataRaw(DiagLayerRaw):
+    """This is a diagnostic layer for data shared accross others
+    """
+
+    diag_variables_raw: List[Union[DiagVariable, OdxLinkRef]]
+    variable_groups: NamedItemList[VariableGroup]
+
+    @property
+    def diag_variables(self) -> NamedItemList[DiagVariable]:
+        return self._diag_variables
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element,
+                doc_frags: List[OdxDocFragment]) -> "EcuSharedDataRaw":
+        # 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
+
+        diag_variables_raw: List[Union[DiagVariable, OdxLinkRef]] = []
+        if (dv_elems := et_element.find("DIAG-VARIABLES")) is not None:
+            for dv_proxy_elem in dv_elems:
+                dv_proxy: Union[OdxLinkRef, DiagVariable]
+                if dv_proxy_elem.tag == "DIAG-VARIABLE-REF":
+                    dv_proxy = OdxLinkRef.from_et(dv_proxy_elem, doc_frags)
+                elif dv_proxy_elem.tag == "DIAG-VARIABLE":
+                    dv_proxy = DiagVariable.from_et(dv_proxy_elem, doc_frags)
+                else:
+                    odxraise()
+
+                diag_variables_raw.append(dv_proxy)
+
+        variable_groups = NamedItemList([
+            VariableGroup.from_et(vg_elem, doc_frags)
+            for vg_elem in et_element.iterfind("VARIABLE-GROUPS/VARIABLE-GROUP")
+        ])
+
+        # Create DiagLayer
+        return EcuSharedDataRaw(
+            diag_variables_raw=diag_variables_raw, variable_groups=variable_groups, **kwargs)
+
+    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+        result = super()._build_odxlinks()
+        for dv_proxy in self.diag_variables_raw:
+            if not isinstance(dv_proxy, OdxLinkRef):
+                result.update(dv_proxy._build_odxlinks())
+
+        return result
+
+    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
+        super()._resolve_odxlinks(odxlinks)
+
+        self._diag_variables: NamedItemList[DiagVariable] = NamedItemList()
+        for dv_proxy in self.diag_variables_raw:
+            if isinstance(dv_proxy, OdxLinkRef):
+                dv = odxlinks.resolve(dv_proxy, DiagVariable)
+            else:
+                dv_proxy._resolve_odxlinks(odxlinks)
+                dv = dv_proxy
+
+            self._diag_variables.append(dv)
+
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
+        super()._resolve_snrefs(context)
+
+        for dv_proxy in self.diag_variables_raw:
+            if not isinstance(dv_proxy, OdxLinkRef):
+                dv_proxy._resolve_snrefs(context)