odxtools 7.1.1__py3-none-any.whl → 7.3.0__py3-none-any.whl

odxtools/database.py

@@ -1,7 +1,7 @@
 # SPDX-License-Identifier: MIT
 from itertools import chain
 from pathlib import Path
-from typing import List, Optional
+from typing import IO, Any, Dict, List, Optional, OrderedDict
 from xml.etree import ElementTree
 from zipfile import ZipFile
 
@@ -13,7 +13,7 @@ from .diaglayer import DiagLayer
 from .diaglayercontainer import DiagLayerContainer
 from .exceptions import odxraise
 from .nameditemlist import NamedItemList
-from .odxlink import OdxLinkDatabase
+from .odxlink import OdxLinkDatabase, OdxLinkId
 
 
 class Database:
@@ -26,69 +26,75 @@ class Database:
                  *,
                  pdx_zip: Optional[ZipFile] = None,
                  odx_d_file_name: Optional[str] = None) -> None:
-        self.model_version = None
-
-        if pdx_zip is None and odx_d_file_name is None:
-            # create an empty database object
-            self._diag_layer_containers = NamedItemList[DiagLayerContainer]()
-            self._comparam_subsets = NamedItemList[ComparamSubset]()
-            self._comparam_specs = NamedItemList[ComparamSpec]()
-            return
-
-        if pdx_zip is not None and odx_d_file_name is not None:
-            raise TypeError("The 'pdx_zip' and 'odx_d_file_name' parameters are mutually exclusive")
-
-        documents: List[ElementTree.Element] = []
-        if pdx_zip is not None:
-            names = list(pdx_zip.namelist())
-            names.sort()
-            for zip_member in names:
-                # The name of ODX files can end with .odx, .odx-d,
-                # .odx-c, .odx-cs, .odx-e, .odx-f, .odx-fd, .odx-m,
-                # .odx-v .  We could test for all that, or just make
-                # sure that the file's suffix starts with .odx
-                if Path(zip_member).suffix.startswith(".odx"):
-                    d = pdx_zip.read(zip_member)
-                    root = ElementTree.fromstring(d)
-                    documents.append(root)
-
-        elif odx_d_file_name is not None:
-            documents.append(ElementTree.parse(odx_d_file_name).getroot())
-
+        self.model_version: Optional[Version] = None
+        self.auxiliary_files: OrderedDict[str, IO[bytes]] = OrderedDict()
+
+        # create an empty database object
+        self._diag_layer_containers = NamedItemList[DiagLayerContainer]()
+        self._comparam_subsets = NamedItemList[ComparamSubset]()
+        self._comparam_specs = NamedItemList[ComparamSpec]()
+
+    def add_pdx_file(self, pdx_file_name: str) -> None:
+        pdx_zip = ZipFile(pdx_file_name)
+
+        for zip_member in pdx_zip.namelist():
+            # The name of ODX files can end with .odx, .odx-d,
+            # .odx-c, .odx-cs, .odx-e, .odx-f, .odx-fd, .odx-m,
+            # .odx-v .  We could test for all that, or just make
+            # sure that the file's suffix starts with .odx
+            p = Path(zip_member)
+            if p.suffix.lower().startswith(".odx"):
+                root = ElementTree.parse(pdx_zip.open(zip_member)).getroot()
+                self._process_xml_tree(root)
+            elif p.name.lower() != "index.xml":
+                self.add_auxiliary_file(zip_member, pdx_zip.open(zip_member))
+
+    def add_odx_file(self, odx_file_name: str) -> None:
+        self._process_xml_tree(ElementTree.parse(odx_file_name).getroot())
+
+    def add_auxiliary_file(self,
+                           aux_file_name: str,
+                           aux_file_obj: Optional[IO[bytes]] = None) -> None:
+        if aux_file_obj is None:
+            aux_file_obj = open(aux_file_name, "rb")
+
+        self.auxiliary_files[aux_file_name] = aux_file_obj
+
+    def _process_xml_tree(self, root: ElementTree.Element) -> None:
         dlcs: List[DiagLayerContainer] = []
         comparam_subsets: List[ComparamSubset] = []
         comparam_specs: List[ComparamSpec] = []
-        for root in documents:
-            # ODX spec version
-            model_version = Version(root.attrib.get("MODEL-VERSION", "2.0"))
-            if self.model_version is not None and self.model_version != model_version:
-                odxraise(f"Different ODX versions used in the same file (ODX {model_version} "
-                         f"and ODX {self.model_version}")
-            self.model_version = model_version
-            dlc = root.find("DIAG-LAYER-CONTAINER")
-            if dlc is not None:
-                dlcs.append(DiagLayerContainer.from_et(dlc, []))
-
-            # In ODX 2.0 there was only COMPARAM-SPEC. In ODX 2.2 the
-            # content of COMPARAM-SPEC was moved to COMPARAM-SUBSET
-            # and COMPARAM-SPEC became a container for PROT-STACKS and
-            # a PROT-STACK references a list of COMPARAM-SUBSET
-            cp_subset = root.find("COMPARAM-SUBSET")
-            if cp_subset is not None:
-                comparam_subsets.append(ComparamSubset.from_et(cp_subset, []))
-
-            cp_spec = root.find("COMPARAM-SPEC")
-            if cp_spec is not None:
-                if model_version < Version("2.2"):
-                    comparam_subsets.append(ComparamSubset.from_et(cp_spec, []))
-                else:  # odx >= 2.2
-                    comparam_specs.append(ComparamSpec.from_et(cp_spec, []))
-
-        self._diag_layer_containers = NamedItemList(dlcs)
-        self._comparam_subsets = NamedItemList(comparam_subsets)
-        self._comparam_specs = NamedItemList(comparam_specs)
-
-        self.refresh()
+
+        # ODX spec version
+        model_version = Version(root.attrib.get("MODEL-VERSION", "2.0"))
+        if self.model_version is not None and self.model_version != model_version:
+            odxraise(f"Different ODX versions used for the same database (ODX {model_version} "
+                     f"and ODX {self.model_version}")
+
+        self.model_version = model_version
+
+        dlc = root.find("DIAG-LAYER-CONTAINER")
+        if dlc is not None:
+            dlcs.append(DiagLayerContainer.from_et(dlc, []))
+
+        # In ODX 2.0 there was only COMPARAM-SPEC. In ODX 2.2 the
+        # content of COMPARAM-SPEC was moved to COMPARAM-SUBSET
+        # and COMPARAM-SPEC became a container for PROT-STACKS and
+        # a PROT-STACK references a list of COMPARAM-SUBSET
+        cp_subset = root.find("COMPARAM-SUBSET")
+        if cp_subset is not None:
+            comparam_subsets.append(ComparamSubset.from_et(cp_subset, []))
+
+        cp_spec = root.find("COMPARAM-SPEC")
+        if cp_spec is not None:
+            if model_version < Version("2.2"):
+                comparam_subsets.append(ComparamSubset.from_et(cp_spec, []))
+            else:  # odx >= 2.2
+                comparam_specs.append(ComparamSpec.from_et(cp_spec, []))
+
+        self._diag_layer_containers.extend(dlcs)
+        self._comparam_subsets.extend(comparam_subsets)
+        self._comparam_specs.extend(comparam_specs)
 
     def refresh(self) -> None:
         # Create wrapper objects
@@ -102,15 +108,7 @@ class Database:
 
         # Build odxlinks
         self._odxlinks = OdxLinkDatabase()
-
-        for subset in self.comparam_subsets:
-            self._odxlinks.update(subset._build_odxlinks())
-
-        for spec in self.comparam_specs:
-            self._odxlinks.update(spec._build_odxlinks())
-
-        for dlc in self.diag_layer_containers:
-            self._odxlinks.update(dlc._build_odxlinks())
+        self._odxlinks.update(self._build_odxlinks())
 
         # Resolve ODXLINK references
         for subset in self.comparam_subsets:
@@ -125,7 +123,21 @@ class Database:
         # let the diaglayers sort out the inherited objects and the
         # short name references
         for dlc in self.diag_layer_containers:
-            dlc._finalize_init(self._odxlinks)
+            dlc._finalize_init(self, self._odxlinks)
+
+    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+        result: Dict[OdxLinkId, Any] = {}
+
+        for subset in self.comparam_subsets:
+            result.update(subset._build_odxlinks())
+
+        for spec in self.comparam_specs:
+            result.update(spec._build_odxlinks())
+
+        for dlc in self.diag_layer_containers:
+            result.update(dlc._build_odxlinks())
+
+        return result
 
     @property
     def odxlinks(self) -> OdxLinkDatabase:

odxtools/dataobjectproperty.py

@@ -1,6 +1,6 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Dict, List, Optional, cast
+from typing import Any, Dict, List, Optional, cast
 from xml.etree import ElementTree
 
 from .compumethods.compumethod import CompuMethod
@@ -10,17 +10,15 @@ from .decodestate import DecodeState
 from .diagcodedtype import DiagCodedType
 from .dopbase import DopBase
 from .encodestate import EncodeState
-from .exceptions import DecodeError, EncodeError, odxassert, odxrequire
+from .exceptions import DecodeError, EncodeError, odxraise, odxrequire
 from .internalconstr import InternalConstr
 from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef
 from .odxtypes import AtomicOdxType, ParameterValue
 from .physicaltype import PhysicalType
+from .snrefcontext import SnRefContext
 from .unit import Unit
 from .utils import dataclass_fields_asdict
 
-if TYPE_CHECKING:
-    from .diaglayer import DiagLayer
-
 
 @dataclass
 class DataObjectProperty(DopBase):
@@ -98,10 +96,10 @@ class DataObjectProperty(DopBase):
         if self.unit_ref:
             self._unit = odxlinks.resolve(self.unit_ref, Unit)
 
-    def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
-        super()._resolve_snrefs(diag_layer)
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
+        super()._resolve_snrefs(context)
 
-        self.diag_coded_type._resolve_snrefs(diag_layer)
+        self.diag_coded_type._resolve_snrefs(context)
 
     @property
     def unit(self) -> Optional[Unit]:
@@ -110,16 +108,6 @@ class DataObjectProperty(DopBase):
     def get_static_bit_length(self) -> Optional[int]:
         return self.diag_coded_type.get_static_bit_length()
 
-    def convert_physical_to_internal(self, physical_value: Any) -> Any:
-        """
-        Convert a physical representation of a parameter to its internal counterpart
-        """
-        odxassert(
-            self.physical_type.base_data_type.isinstance(physical_value),
-            f"Expected {self.physical_type.base_data_type.value}, got {type(physical_value)}")
-
-        return self.compu_method.convert_physical_to_internal(physical_value)
-
     def encode_into_pdu(self, physical_value: ParameterValue, encode_state: EncodeState) -> None:
         """
         Convert a physical representation of a parameter to a string bytes that can be send over the wire
@@ -129,7 +117,10 @@ class DataObjectProperty(DopBase):
                 f"The value {repr(physical_value)} of type {type(physical_value).__name__}"
                 f" is not a valid.")
 
-        internal_value = self.convert_physical_to_internal(physical_value)
+        if not isinstance(physical_value, (int, float, str, bytes, bytearray)):
+            odxraise(f"Invalid type '{type(physical_value).__name__}' for physical value. "
+                     f"(Expect atomic type!)")
+        internal_value = self.compu_method.convert_physical_to_internal(physical_value)
         self.diag_coded_type.encode_into_pdu(internal_value, encode_state)
 
     def decode_from_pdu(self, decode_state: DecodeState) -> ParameterValue:

odxtools/decodestate.py

@@ -1,11 +1,11 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass, field
-from typing import TYPE_CHECKING, Dict, cast
+from typing import TYPE_CHECKING, Dict, List, Optional, Tuple, cast
 
 import odxtools.exceptions as exceptions
 
 from .exceptions import DecodeError
-from .odxtypes import AtomicOdxType, DataType
+from .odxtypes import AtomicOdxType, DataType, ParameterValue
 
 try:
     import bitstruct.c as bitstruct
@@ -13,6 +13,7 @@ except ImportError:
     import bitstruct
 
 if TYPE_CHECKING:
+    from .parameters.parameter import Parameter
     from .tablerow import TableRow
 
 
@@ -46,6 +47,11 @@ class DecodeState:
     #: values of the table key parameters decoded so far
     table_keys: Dict[str, "TableRow"] = field(default_factory=dict)
 
+    #: List of parameters that have been decoded so far. The journal
+    #: is used by some types of parameters which depend on the values of
+    #: other parameters; i.e., environment data description parameters
+    journal: List[Tuple["Parameter", Optional[ParameterValue]]] = field(default_factory=list)
+
     def extract_atomic_value(
         self,
         bit_length: int,

odxtools/description.py

@@ -0,0 +1,47 @@
+from dataclasses import dataclass
+from typing import List, Optional
+from xml.etree import ElementTree
+
+from .exceptions import odxrequire
+from .odxlink import OdxDocFragment
+
+
+@dataclass
+class Description:
+    text: str
+    external_docs: List[str]
+    text_identifier: Optional[str]
+
+    @staticmethod
+    def from_et(et_element: Optional[ElementTree.Element],
+                doc_frags: List[OdxDocFragment]) -> Optional["Description"]:
+        if et_element is None:
+            return None
+
+        # Extract the contents of the tag as a XHTML string.
+        raw_string = et_element.text or ""
+        for e in et_element:
+            if e.tag == "EXTERNAL-DOCS":
+                break
+            raw_string += ElementTree.tostring(e, encoding="unicode")
+
+        # remove white spaces at the beginning and at the end of all
+        # extracted lines
+        stripped_lines = [x.strip() for x in raw_string.split("\n")]
+
+        text = "\n".join(stripped_lines).strip()
+
+        text_identifier = et_element.get("TI")
+
+        external_docs = \
+            [
+                odxrequire(ed.get("HREF")) for ed in et_element.iterfind("EXTERNAL-DOCS/EXTERNAL-DOC")
+            ]
+        return Description(text=text, text_identifier=text_identifier, external_docs=external_docs)
+
+    @staticmethod
+    def from_string(text: str) -> "Description":
+        return Description(text=text, external_docs=[], text_identifier=None)
+
+    def __str__(self) -> str:
+        return self.text

odxtools/determinenumberofitems.py

@@ -1,13 +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 .dataobjectproperty import DataObjectProperty
 from .exceptions import odxrequire
 from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef
-
-if TYPE_CHECKING:
-    from .diaglayer import DiagLayer
+from .snrefcontext import SnRefContext
 
 
 @dataclass
@@ -39,7 +38,7 @@ class DetermineNumberOfItems:
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
         self._dop = odxlinks.resolve(self.dop_ref, DataObjectProperty)
 
-    def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
         pass
 
     @property

odxtools/diagcodedtype.py

@@ -1,16 +1,14 @@
 # SPDX-License-Identifier: MIT
-import abc
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Dict, Literal, Optional, Union
+from typing import Any, Dict, List, Literal, Optional, Union, cast
+from xml.etree import ElementTree
 
 from .decodestate import DecodeState
 from .encodestate import EncodeState
-from .exceptions import odxassert, odxraise
-from .odxlink import OdxLinkDatabase, OdxLinkId
-from .odxtypes import AtomicOdxType, DataType
-
-if TYPE_CHECKING:
-    from .diaglayer import DiagLayer
+from .exceptions import odxassert, odxraise, odxrequire
+from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
+from .odxtypes import AtomicOdxType, DataType, odxstr_to_bool
+from .snrefcontext import SnRefContext
 
 # Allowed diag-coded types
 DctType = Literal[
@@ -22,12 +20,30 @@ DctType = Literal[
 
 
 @dataclass
-class DiagCodedType(abc.ABC):
+class DiagCodedType:
 
     base_data_type: DataType
     base_type_encoding: Optional[str]
     is_highlow_byte_order_raw: Optional[bool]
 
+    @staticmethod
+    def from_et(et_element: ElementTree.Element,
+                doc_frags: List[OdxDocFragment]) -> "DiagCodedType":
+        base_data_type_str = odxrequire(et_element.get("BASE-DATA-TYPE"))
+        try:
+            base_data_type = DataType(base_data_type_str)
+        except ValueError:
+            odxraise(f"Unknown base data type {base_data_type_str}")
+            base_data_type = cast(DataType, None)
+
+        base_type_encoding = et_element.get("BASE-TYPE-ENCODING")
+        is_highlow_byte_order_raw = odxstr_to_bool(et_element.get("IS-HIGHLOW-BYTE-ORDER"))
+
+        return DiagCodedType(
+            base_data_type=base_data_type,
+            base_type_encoding=base_type_encoding,
+            is_highlow_byte_order_raw=is_highlow_byte_order_raw)
+
     def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:  # noqa: B027
         return {}
 
@@ -35,7 +51,7 @@ class DiagCodedType(abc.ABC):
         """Recursively resolve any odxlinks references"""
         pass
 
-    def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:  # noqa: B027
+    def _resolve_snrefs(self, context: SnRefContext) -> None:  # noqa: B027
         """Recursively resolve any short-name references"""
         pass
 
@@ -43,9 +59,10 @@ class DiagCodedType(abc.ABC):
         return None
 
     @property
-    @abc.abstractmethod
     def dct_type(self) -> DctType:
-        pass
+        odxraise(f"Class {type(self).__name__} does not override required method "
+                 f"dct_type()", NotImplementedError)
+        return cast(DctType, None)
 
     @property
     def is_highlow_byte_order(self) -> bool:

odxtools/diagcomm.py

@@ -6,13 +6,13 @@ from xml.etree import ElementTree
 
 from .admindata import AdminData
 from .audience import Audience
-from .createsdgs import create_sdgs_from_et
 from .element import IdentifiableElement
 from .exceptions import odxraise, odxrequire
 from .functionalclass import FunctionalClass
 from .nameditemlist import NamedItemList
 from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef, resolve_snref
 from .odxtypes import odxstr_to_bool
+from .snrefcontext import SnRefContext
 from .specialdatagroup import SpecialDataGroup
 from .state import State
 from .statetransition import StateTransition
@@ -76,7 +76,9 @@ class DiagComm(IdentifiableElement):
         kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, doc_frags))
 
         admin_data = AdminData.from_et(et_element.find("ADMIN-DATA"), 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")
+        ]
 
         functional_class_refs = [
             odxrequire(OdxLinkRef.from_et(el, doc_frags))
@@ -201,22 +203,24 @@ class DiagComm(IdentifiableElement):
         self._state_transitions = NamedItemList(
             [odxlinks.resolve(stt_ref, StateTransition) for stt_ref in self.state_transition_refs])
 
-    def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
         if self.admin_data:
-            self.admin_data._resolve_snrefs(diag_layer)
+            self.admin_data._resolve_snrefs(context)
 
         if self.audience:
-            self.audience._resolve_snrefs(diag_layer)
+            self.audience._resolve_snrefs(context)
 
         for sdg in self.sdgs:
-            sdg._resolve_snrefs(diag_layer)
+            sdg._resolve_snrefs(context)
 
         if TYPE_CHECKING:
+            diag_layer = odxrequire(context.diag_layer)
             self._protocols = NamedItemList([
                 resolve_snref(prot_snref, diag_layer.protocols, DiagLayer)
                 for prot_snref in self.protocol_snrefs
             ])
         else:
+            diag_layer = odxrequire(context.diag_layer)
             self._protocols = NamedItemList([
                 resolve_snref(prot_snref, diag_layer.protocols)
                 for prot_snref in self.protocol_snrefs

odxtools/diagdatadictionaryspec.py

@@ -1,12 +1,11 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
 from itertools import chain
-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 .basicstructure import BasicStructure
-from .createsdgs import create_sdgs_from_et
 from .dataobjectproperty import DataObjectProperty
 from .dopbase import DopBase
 from .dtcdop import DtcDop
@@ -19,15 +18,13 @@ from .exceptions import odxraise
 from .multiplexer import Multiplexer
 from .nameditemlist import NamedItemList
 from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
+from .snrefcontext import SnRefContext
 from .specialdatagroup import SpecialDataGroup
 from .staticfield import StaticField
 from .structure import Structure
 from .table import Table
 from .unitspec import UnitSpec
 
-if TYPE_CHECKING:
-    from .diaglayer import DiagLayer
-
 
 @dataclass
 class DiagDataDictionarySpec:
@@ -135,7 +132,9 @@ class DiagDataDictionarySpec:
             for table_element in et_element.iterfind("TABLES/TABLE")
         ]
 
-        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 DiagDataDictionarySpec(
             admin_data=admin_data,
@@ -219,35 +218,35 @@ class DiagDataDictionarySpec:
         for sdg in self.sdgs:
             sdg._resolve_odxlinks(odxlinks)
 
-    def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
         if self.admin_data is not None:
-            self.admin_data._resolve_snrefs(diag_layer)
+            self.admin_data._resolve_snrefs(context)
         for dtc_dop in self.dtc_dops:
-            dtc_dop._resolve_snrefs(diag_layer)
+            dtc_dop._resolve_snrefs(context)
         for env_data_desc in self.env_data_descs:
-            env_data_desc._resolve_snrefs(diag_layer)
+            env_data_desc._resolve_snrefs(context)
         for data_object_prop in self.data_object_props:
-            data_object_prop._resolve_snrefs(diag_layer)
+            data_object_prop._resolve_snrefs(context)
         for structure in self.structures:
-            structure._resolve_snrefs(diag_layer)
+            structure._resolve_snrefs(context)
         for static_field in self.static_fields:
-            static_field._resolve_snrefs(diag_layer)
+            static_field._resolve_snrefs(context)
         for dynamic_length_field in self.dynamic_length_fields:
-            dynamic_length_field._resolve_snrefs(diag_layer)
+            dynamic_length_field._resolve_snrefs(context)
         for dynamic_endmarker_field in self.dynamic_endmarker_fields:
-            dynamic_endmarker_field._resolve_snrefs(diag_layer)
+            dynamic_endmarker_field._resolve_snrefs(context)
         for end_of_pdu_field in self.end_of_pdu_fields:
-            end_of_pdu_field._resolve_snrefs(diag_layer)
+            end_of_pdu_field._resolve_snrefs(context)
         for mux in self.muxs:
-            mux._resolve_snrefs(diag_layer)
+            mux._resolve_snrefs(context)
         for env_data in self.env_datas:
-            env_data._resolve_snrefs(diag_layer)
+            env_data._resolve_snrefs(context)
         if self.unit_spec is not None:
-            self.unit_spec._resolve_snrefs(diag_layer)
+            self.unit_spec._resolve_snrefs(context)
         for table in self.tables:
-            table._resolve_snrefs(diag_layer)
+            table._resolve_snrefs(context)
         for sdg in self.sdgs:
-            sdg._resolve_snrefs(diag_layer)
+            sdg._resolve_snrefs(context)
 
     @property
     def all_data_object_properties(self) -> NamedItemList[DopBase]: