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

odxtools/diaglayercontainer.py

@@ -1,13 +1,11 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
 from itertools import chain
-from typing import Any, Dict, List, Optional, Union
+from typing import TYPE_CHECKING, Any, Dict, List, Optional, Union
 from xml.etree import ElementTree
 
 from .admindata import AdminData
 from .companydata import CompanyData
-from .createcompanydatas import create_company_datas_from_et
-from .createsdgs import create_sdgs_from_et
 from .diaglayer import DiagLayer
 from .element import IdentifiableElement
 from .exceptions import odxrequire
@@ -16,6 +14,9 @@ from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
 from .specialdatagroup import SpecialDataGroup
 from .utils import dataclass_fields_asdict
 
+if TYPE_CHECKING:
+    from .database import Database
+
 
 @dataclass
 class DiagLayerContainer(IdentifiableElement):
@@ -48,7 +49,10 @@ class DiagLayerContainer(IdentifiableElement):
         kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, doc_frags))
 
         admin_data = AdminData.from_et(et_element.find("ADMIN-DATA"), doc_frags)
-        company_datas = create_company_datas_from_et(et_element.find("COMPANY-DATAS"), doc_frags)
+        company_datas = NamedItemList([
+            CompanyData.from_et(cde, doc_frags)
+            for cde in et_element.iterfind("COMPANY-DATAS/COMPANY-DATA")
+        ])
         ecu_shared_datas = NamedItemList([
             DiagLayer.from_et(dl_element, doc_frags)
             for dl_element in et_element.iterfind("ECU-SHARED-DATAS/ECU-SHARED-DATA")
@@ -69,7 +73,9 @@ class DiagLayerContainer(IdentifiableElement):
             DiagLayer.from_et(dl_element, doc_frags)
             for dl_element in et_element.iterfind("ECU-VARIANTS/ECU-VARIANT")
         ])
-        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 DiagLayerContainer(
             admin_data=admin_data,
@@ -124,17 +130,17 @@ class DiagLayerContainer(IdentifiableElement):
         for ecu_variant in self.ecu_variants:
             ecu_variant._resolve_odxlinks(odxlinks)
 
-    def _finalize_init(self, odxlinks: OdxLinkDatabase) -> None:
+    def _finalize_init(self, database: "Database", odxlinks: OdxLinkDatabase) -> None:
         for ecu_shared_data in self.ecu_shared_datas:
-            ecu_shared_data._finalize_init(odxlinks)
+            ecu_shared_data._finalize_init(database, odxlinks)
         for protocol in self.protocols:
-            protocol._finalize_init(odxlinks)
+            protocol._finalize_init(database, odxlinks)
         for functional_group in self.functional_groups:
-            functional_group._finalize_init(odxlinks)
+            functional_group._finalize_init(database, odxlinks)
         for base_variant in self.base_variants:
-            base_variant._finalize_init(odxlinks)
+            base_variant._finalize_init(database, odxlinks)
         for ecu_variant in self.ecu_variants:
-            ecu_variant._finalize_init(odxlinks)
+            ecu_variant._finalize_init(database, odxlinks)
 
     @property
     def diag_layers(self) -> NamedItemList[DiagLayer]:

odxtools/diaglayerraw.py

@@ -1,7 +1,7 @@
 # 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
@@ -10,7 +10,6 @@ from .companydata import CompanyData
 from .comparaminstance import ComparamInstance
 from .comparamspec import ComparamSpec
 from .comparamsubset import ComparamSubset
-from .createsdgs import create_sdgs_from_et
 from .diagcomm import DiagComm
 from .diagdatadictionaryspec import DiagDataDictionarySpec
 from .diaglayertype import DiagLayerType
@@ -26,13 +25,11 @@ from .protstack import ProtStack
 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 .utils import dataclass_fields_asdict
 
-if TYPE_CHECKING:
-    from .diaglayer import DiagLayer
-
 
 @dataclass
 class DiagLayerRaw(IdentifiableElement):
@@ -153,7 +150,9 @@ class DiagLayerRaw(IdentifiableElement):
             for el in et_element.iterfind("ADDITIONAL-AUDIENCES/ADDITIONAL-AUDIENCE")
         ]
 
-        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")
+        ]
 
         parent_refs = [
             ParentRef.from_et(pr_el, doc_frags)
@@ -282,7 +281,7 @@ class DiagLayerRaw(IdentifiableElement):
         for comparam in self.comparams:
             comparam._resolve_odxlinks(odxlinks)
 
-    def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
         self._prot_stack: Optional[ProtStack] = None
         if self.prot_stack_snref is not None:
             cp_spec = self.comparam_spec
@@ -292,36 +291,36 @@ class DiagLayerRaw(IdentifiableElement):
 
         # 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)
+            company_data._resolve_snrefs(context)
         for functional_class in self.functional_classes:
-            functional_class._resolve_snrefs(diag_layer)
+            functional_class._resolve_snrefs(context)
         for diag_comm in self.diag_comms:
             if isinstance(diag_comm, OdxLinkRef):
                 continue
-            diag_comm._resolve_snrefs(diag_layer)
+            diag_comm._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 sdg in self.sdgs:
-            sdg._resolve_snrefs(diag_layer)
+            sdg._resolve_snrefs(context)
         for parent_ref in self.parent_refs:
-            parent_ref._resolve_snrefs(diag_layer)
+            parent_ref._resolve_snrefs(context)
         for comparam in self.comparams:
-            comparam._resolve_snrefs(diag_layer)
+            comparam._resolve_snrefs(context)
 
     @property
     def comparam_spec(self) -> Optional[Union[ComparamSpec, ComparamSubset]]:

odxtools/diagnostictroublecode.py

@@ -1,19 +1,16 @@
 # 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, Union
 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):
@@ -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,7 +1,7 @@
 # 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
@@ -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"
@@ -175,16 +173,20 @@ 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
         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]] = [

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,21 +1,18 @@
 # 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):
@@ -37,7 +34,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)
 
@@ -53,9 +52,9 @@ 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

odxtools/dtcdop.py

@@ -1,7 +1,6 @@
 # SPDX-License-Identifier: MIT
-# from dataclasses import dataclass, field
 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 typing_extensions import override
@@ -19,11 +18,9 @@ from .nameditemlist import NamedItemList
 from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef
 from .odxtypes import ParameterValue, odxstr_to_bool
 from .physicaltype import PhysicalType
+from .snrefcontext import SnRefContext
 from .utils import dataclass_fields_asdict
 
-if TYPE_CHECKING:
-    from .diaglayer import DiagLayer
-
 
 @dataclass
 class DtcDop(DopBase):
@@ -177,9 +174,9 @@ class DtcDop(DopBase):
         linked_dtc_dops = [odxlinks.resolve(x, DtcDop) for x in self.linked_dtc_dop_refs]
         self._linked_dtc_dops = NamedItemList(linked_dtc_dops)
 
-    def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
-        super()._resolve_snrefs(diag_layer)
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
+        super()._resolve_snrefs(context)
 
         for dtc_proxy in self.dtcs_raw:
             if isinstance(dtc_proxy, DiagnosticTroubleCode):
-                dtc_proxy._resolve_snrefs(diag_layer)
+                dtc_proxy._resolve_snrefs(context)

odxtools/dynamicendmarkerfield.py

@@ -1,6 +1,6 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Dict, List, Sequence
+from typing import Any, Dict, List, Sequence
 from xml.etree import ElementTree
 
 from typing_extensions import override
@@ -13,11 +13,9 @@ from .exceptions import DecodeError, EncodeError, odxassert, odxraise, odxrequir
 from .field import Field
 from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
 from .odxtypes import AtomicOdxType, ParameterValue
+from .snrefcontext import SnRefContext
 from .utils import dataclass_fields_asdict
 
-if TYPE_CHECKING:
-    from .diaglayer import DiagLayer
-
 
 @dataclass
 class DynamicEndmarkerField(Field):
@@ -49,8 +47,8 @@ class DynamicEndmarkerField(Field):
 
         self._termination_value = tv_physical
 
-    def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
-        super()._resolve_snrefs(diag_layer)
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
+        super()._resolve_snrefs(context)
 
     @property
     def dyn_end_dop(self) -> DataObjectProperty:
@@ -81,8 +79,17 @@ class DynamicEndmarkerField(Field):
         encode_state.is_end_of_pdu = orig_is_end_of_pdu
 
         if not encode_state.is_end_of_pdu:
-            # only add an endmarker if we are not at the end of the PDU
+            # only add an endmarker if we are not at the end of the
+            # PDU. note that since section 7.3.6.10.5 of the MCD-2
+            # specification states that the data used by the endmarker
+            # ought to be considered to be not consumed (why?!), we
+            # need to keep the cursor where it is before adding the
+            # endmarker. (we still consider its bits to be used
+            # "used", in order to produce a warning if it is attempted
+            # to be overridden.)
+            tmp_cursor = encode_state.cursor_byte_position
             self.dyn_end_dop.encode_into_pdu(self.termination_value, encode_state)
+            encode_state.cursor_byte_position = tmp_cursor
 
     @override
     def decode_from_pdu(self, decode_state: DecodeState) -> ParameterValue:
@@ -91,7 +98,6 @@ class DynamicEndmarkerField(Field):
                   "No bit position can be specified for dynamic endmarker fields!")
 
         orig_origin = decode_state.origin_byte_position
-        orig_cursor = decode_state.cursor_byte_position
         decode_state.origin_byte_position = decode_state.cursor_byte_position
 
         result: List[ParameterValue] = []
@@ -106,6 +112,14 @@ class DynamicEndmarkerField(Field):
             try:
                 tv_candidate = self.dyn_end_dop.decode_from_pdu(decode_state)
                 if tv_candidate == self.termination_value:
+                    # note that section 7.3.6.10.5 of the MCD-2
+                    # specification states that the bytes occupied by
+                    # the endmarker ought to be considered to be not
+                    # consumed (why?!), i.e., we need to keep the
+                    # cursor where it is before adding the
+                    # endmarker. (we still consider its to be used
+                    # "used", though.)
+                    decode_state.cursor_byte_position = tmp_cursor
                     break
             except DecodeError:
                 pass
@@ -114,6 +128,5 @@ class DynamicEndmarkerField(Field):
             result.append(self.structure.decode_from_pdu(decode_state))
 
         decode_state.origin_byte_position = orig_origin
-        decode_state.cursor_byte_position = max(orig_cursor, decode_state.cursor_byte_position)
 
         return result

odxtools/dynamiclengthfield.py

@@ -1,6 +1,6 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Dict, List, Sequence
+from typing import Any, Dict, List, Sequence
 from xml.etree import ElementTree
 
 from typing_extensions import override
@@ -12,11 +12,9 @@ from .exceptions import DecodeError, EncodeError, odxassert, odxraise, odxrequir
 from .field import Field
 from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
 from .odxtypes import ParameterValue
+from .snrefcontext import SnRefContext
 from .utils import dataclass_fields_asdict
 
-if TYPE_CHECKING:
-    from .diaglayer import DiagLayer
-
 
 @dataclass
 class DynamicLengthField(Field):
@@ -45,9 +43,9 @@ class DynamicLengthField(Field):
         super()._resolve_odxlinks(odxlinks)
         self.determine_number_of_items._resolve_odxlinks(odxlinks)
 
-    def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
-        super()._resolve_snrefs(diag_layer)
-        self.determine_number_of_items._resolve_snrefs(diag_layer)
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
+        super()._resolve_snrefs(context)
+        self.determine_number_of_items._resolve_snrefs(context)
 
     @override
     def encode_into_pdu(self, physical_value: ParameterValue, encode_state: EncodeState) -> None:
@@ -61,7 +59,6 @@ class DynamicLengthField(Field):
                 f"got {type(physical_value)}", EncodeError)
 
         # move the origin to the cursor position
-        orig_cursor = encode_state.cursor_byte_position
         orig_origin = encode_state.origin_byte_position
         encode_state.origin_byte_position = encode_state.cursor_byte_position
 
@@ -92,7 +89,6 @@ class DynamicLengthField(Field):
 
         # move cursor and origin positions
         encode_state.origin_byte_position = orig_origin
-        encode_state.cursor_byte_position = max(orig_cursor, encode_state.cursor_byte_position)
 
     @override
     def decode_from_pdu(self, decode_state: DecodeState) -> ParameterValue:
@@ -101,7 +97,6 @@ class DynamicLengthField(Field):
                   "No bit position can be specified for dynamic length fields!")
 
         orig_origin = decode_state.origin_byte_position
-        orig_cursor = decode_state.cursor_byte_position
 
         det_num_items = self.determine_number_of_items
         decode_state.origin_byte_position = decode_state.cursor_byte_position
@@ -125,6 +120,5 @@ class DynamicLengthField(Field):
             result.append(self.structure.decode_from_pdu(decode_state))
 
         decode_state.origin_byte_position = orig_origin
-        decode_state.cursor_byte_position = max(orig_cursor, decode_state.cursor_byte_position)
 
         return result

odxtools/element.py

@@ -2,16 +2,17 @@ from dataclasses import dataclass
 from typing import List, Optional
 from xml.etree import ElementTree
 
+from .description import Description
 from .exceptions import odxrequire
 from .odxlink import OdxDocFragment, OdxLinkId
-from .utils import create_description_from_et, dataclass_fields_asdict
+from .utils import dataclass_fields_asdict
 
 
 @dataclass
 class NamedElement:
     short_name: str
     long_name: Optional[str]
-    description: Optional[str]
+    description: Optional[Description]
 
     @staticmethod
     def from_et(
@@ -22,7 +23,7 @@ class NamedElement:
         return NamedElement(
             short_name=odxrequire(et_element.findtext("SHORT-NAME")),
             long_name=et_element.findtext("LONG-NAME"),
-            description=create_description_from_et(et_element.find("DESC")),
+            description=Description.from_et(et_element.find("DESC"), doc_frags),
         )
 
 

odxtools/endofpdufield.py

@@ -72,7 +72,6 @@ class EndOfPduField(Field):
                   "No bit position can be specified for end-of-pdu fields!")
 
         orig_origin = decode_state.origin_byte_position
-        orig_cursor = decode_state.cursor_byte_position
         decode_state.origin_byte_position = decode_state.cursor_byte_position
 
         result: List[ParameterValue] = []
@@ -84,6 +83,5 @@ class EndOfPduField(Field):
             result.append(self.structure.decode_from_pdu(decode_state))
 
         decode_state.origin_byte_position = orig_origin
-        decode_state.cursor_byte_position = max(orig_cursor, decode_state.cursor_byte_position)
 
         return result

odxtools/environmentdatadescription.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 typing_extensions import override
@@ -12,11 +12,9 @@ from .environmentdata import EnvironmentData
 from .exceptions import odxraise, odxrequire
 from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef
 from .odxtypes import ParameterValue
+from .snrefcontext import SnRefContext
 from .utils import dataclass_fields_asdict
 
-if TYPE_CHECKING:
-    from .diaglayer import DiagLayer
-
 
 @dataclass
 class EnvironmentDataDescription(ComplexDop):
@@ -87,12 +85,12 @@ class EnvironmentDataDescription(ComplexDop):
             for ed in self.env_datas:
                 ed._resolve_odxlinks(odxlinks)
 
-    def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
         # ODX 2.0 specifies environment data objects here, ODX 2.2
         # uses references
         if self.env_data_refs:
             for ed in self.env_datas:
-                ed._resolve_snrefs(diag_layer)
+                ed._resolve_snrefs(context)
 
     @override
     def encode_into_pdu(self, physical_value: Optional[ParameterValue],

odxtools/exceptions.py

@@ -40,7 +40,7 @@ def odxraise(message: Optional[str] = None, error_type: Type[Exception] = OdxErr
         else:
             raise error_type(message)
     elif message is not None:
-        logger.warn(message)
+        logger.warning(message)
 
 
 def odxassert(condition: bool,

odxtools/field.py

@@ -1,5 +1,6 @@
+# SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, List, Optional
+from typing import List, Optional
 from xml.etree import ElementTree
 
 from .basicstructure import BasicStructure
@@ -8,11 +9,9 @@ from .environmentdatadescription import EnvironmentDataDescription
 from .exceptions import odxassert, odxrequire
 from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkRef, resolve_snref
 from .odxtypes import odxstr_to_bool
+from .snrefcontext import SnRefContext
 from .utils import dataclass_fields_asdict
 
-if TYPE_CHECKING:
-    from .diaglayer import DiagLayer
-
 
 @dataclass
 class Field(ComplexDop):
@@ -80,13 +79,14 @@ class Field(ComplexDop):
             self._env_data_desc = odxlinks.resolve(self.env_data_desc_ref,
                                                    EnvironmentDataDescription)
 
-    def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
         """Recursively resolve any short-name references"""
+        ddd_spec = odxrequire(context.diag_layer).diag_data_dictionary_spec
+
         if self.structure_snref is not None:
-            structures = diag_layer.diag_data_dictionary_spec.structures
-            self._structure = resolve_snref(self.structure_snref, structures, BasicStructure)
+            self._structure = resolve_snref(self.structure_snref, ddd_spec.structures,
+                                            BasicStructure)
 
         if self.env_data_desc_snref is not None:
-            env_data_descs = diag_layer.diag_data_dictionary_spec.env_data_descs
-            self._env_data_desc = resolve_snref(self.env_data_desc_snref, env_data_descs,
+            self._env_data_desc = resolve_snref(self.env_data_desc_snref, ddd_spec.env_data_descs,
                                                 EnvironmentDataDescription)