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

odxtools/__init__.py

@@ -62,11 +62,13 @@ References
 - _`[ISO22901]` The ISO 22901 Standard: https://www.iso.org/standard/41207.html
 
 """
-from .load_file import load_file as load_file  # noqa: F401
-from .load_odx_d_file import load_odx_d_file as load_odx_d_file  # noqa: F401
-from .load_pdx_file import load_pdx_file as load_pdx_file  # noqa: F401
+from .loadfile import load_directory as load_directory  # noqa: F401
+from .loadfile import load_file as load_file  # noqa: F401
+from .loadfile import load_files  # noqa: F401
+from .loadfile import load_odx_d_file as load_odx_d_file  # noqa: F401
+from .loadfile import load_pdx_file as load_pdx_file  # noqa: F401
 from .version import __version__ as __version__  # noqa: F401
-from .write_pdx_file import write_pdx_file as write_pdx_file  # noqa: F401
+from .writepdxfile import write_pdx_file as write_pdx_file  # noqa: F401
 
 __author__ = "Katrin Bauer"
 

odxtools/additionalaudience.py

@@ -1,15 +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 .element import IdentifiableElement
 from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
+from .snrefcontext import SnRefContext
 from .utils import dataclass_fields_asdict
 
-if TYPE_CHECKING:
-    from .diaglayer import DiagLayer
-
 
 @dataclass
 class AdditionalAudience(IdentifiableElement):
@@ -30,5 +28,5 @@ class AdditionalAudience(IdentifiableElement):
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
         pass
 
-    def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
         pass

odxtools/admindata.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 .companydocinfo import CompanyDocInfo
 from .docrevision import DocRevision
 from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
-
-if TYPE_CHECKING:
-    from .diaglayer import DiagLayer
+from .snrefcontext import SnRefContext
 
 
 @dataclass
@@ -54,9 +52,9 @@ class AdminData:
         for dr in self.doc_revisions:
             dr._resolve_odxlinks(odxlinks)
 
-    def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
         for cdi in self.company_doc_infos:
-            cdi._resolve_snrefs(diag_layer)
+            cdi._resolve_snrefs(context)
 
         for dr in self.doc_revisions:
-            dr._resolve_snrefs(diag_layer)
+            dr._resolve_snrefs(context)

odxtools/audience.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 .additionalaudience import AdditionalAudience
 from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef
 from .odxtypes import odxstr_to_bool
-
-if TYPE_CHECKING:
-    from .diaglayer import DiagLayer
+from .snrefcontext import SnRefContext
 
 
 @dataclass
@@ -94,5 +92,5 @@ class Audience:
             odxlinks.resolve(ref, AdditionalAudience) for ref in self.disabled_audience_refs
         ]
 
-    def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
         pass

odxtools/basecomparam.py

@@ -1,17 +1,15 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
 from enum import Enum
-from typing import TYPE_CHECKING, Any, Dict, List, Optional, cast
+from typing import Any, Dict, List, Optional, cast
 from xml.etree import ElementTree
 
 from .element import IdentifiableElement
 from .exceptions import odxraise, odxrequire
 from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
+from .snrefcontext import SnRefContext
 from .utils import dataclass_fields_asdict
 
-if TYPE_CHECKING:
-    from .diaglayer import DiagLayer
-
 
 class StandardizationLevel(Enum):
     STANDARD = "STANDARD"
@@ -74,5 +72,5 @@ class BaseComparam(IdentifiableElement):
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
         pass
 
-    def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
         pass

odxtools/basicstructure.py

@@ -1,7 +1,7 @@
 # SPDX-License-Identifier: MIT
 import warnings
 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 typing_extensions import override
@@ -10,7 +10,7 @@ from .complexdop import ComplexDop
 from .dataobjectproperty import DataObjectProperty
 from .decodestate import DecodeState
 from .encodestate import EncodeState
-from .exceptions import DecodeError, EncodeError, OdxWarning, odxassert, odxraise, strict_mode
+from .exceptions import EncodeError, OdxWarning, odxassert, odxraise
 from .nameditemlist import NamedItemList
 from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
 from .odxtypes import ParameterDict, ParameterValue, ParameterValueDict
@@ -18,16 +18,13 @@ from .parameters.codedconstparameter import CodedConstParameter
 from .parameters.createanyparameter import create_any_parameter_from_et
 from .parameters.lengthkeyparameter import LengthKeyParameter
 from .parameters.matchingrequestparameter import MatchingRequestParameter
-from .parameters.nrcconstparameter import NrcConstParameter
 from .parameters.parameter import Parameter
 from .parameters.parameterwithdop import ParameterWithDOP
 from .parameters.physicalconstantparameter import PhysicalConstantParameter
 from .parameters.tablekeyparameter import TableKeyParameter
+from .snrefcontext import SnRefContext
 from .utils import dataclass_fields_asdict
 
-if TYPE_CHECKING:
-    from .diaglayer import DiagLayer
-
 
 @dataclass
 class BasicStructure(ComplexDop):
@@ -77,10 +74,11 @@ class BasicStructure(ComplexDop):
 
         for param in self.parameters:
             if (isinstance(param, MatchingRequestParameter) and param.request_byte_position < len(request_prefix)) or \
-                isinstance(param, (CodedConstParameter, NrcConstParameter, PhysicalConstantParameter)):
+                isinstance(param, (CodedConstParameter, PhysicalConstantParameter)):
                 param.encode_into_pdu(physical_value=None, encode_state=encode_state)
             else:
                 break
+
         return encode_state.coded_message
 
     @property
@@ -156,15 +154,14 @@ class BasicStructure(ComplexDop):
                 f"{encode_state.cursor_bit_position}", EncodeError)
             encode_state.bit_position = 0
 
-        orig_cursor = encode_state.cursor_byte_position
         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
 
-        # in strict mode, ensure that no values for unknown parameters are specified.
-        if strict_mode:
+        # ensure that no values for unknown parameters are specified.
+        if not encode_state.allow_unknown_parameters:
             param_names = {param.short_name for param in self.parameters}
             for param_value_name in physical_value:
                 if param_value_name not in param_names:
@@ -196,8 +193,10 @@ class BasicStructure(ComplexDop):
                 odxraise(f"No value for required parameter {param.short_name} specified",
                          EncodeError)
 
-            param.encode_into_pdu(
-                physical_value=physical_value.get(param.short_name), encode_state=encode_state)
+            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
         if self.byte_size is not None:
@@ -227,7 +226,6 @@ class BasicStructure(ComplexDop):
                                           encode_state.origin_byte_position)
 
         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:
@@ -240,6 +238,7 @@ class BasicStructure(ComplexDop):
         for param in self.parameters:
             value = param.decode_from_pdu(decode_state)
 
+            decode_state.journal.append((param, value))
             result[param.short_name] = value
 
         # decoding of the structure finished. go back the original origin.
@@ -251,13 +250,6 @@ class BasicStructure(ComplexDop):
         decode_state = DecodeState(coded_message=message)
         param_values = self.decode_from_pdu(decode_state)
 
-        if len(message) != decode_state.cursor_byte_position:
-            odxraise(
-                f"The message {message.hex()} probably could not be completely parsed:"
-                f" Expected length of {decode_state.cursor_byte_position} but got {len(message)}.",
-                DecodeError)
-            return {}
-
         if not isinstance(param_values, dict):
             odxraise("Decoding structures must result in a dictionary")
 
@@ -301,9 +293,13 @@ class BasicStructure(ComplexDop):
         for param in self.parameters:
             param._resolve_odxlinks(odxlinks)
 
-    def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
         """Recursively resolve any references (odxlinks or sn-refs)"""
-        super()._resolve_snrefs(diag_layer)
+        context.parameters = self.parameters
+
+        super()._resolve_snrefs(context)
 
         for param in self.parameters:
-            param._parameter_resolve_snrefs(diag_layer, param_list=self.parameters)
+            param._resolve_snrefs(context)
+
+        context.parameters = None

odxtools/cli/_parser_utils.py

@@ -5,7 +5,7 @@ import argparse
 from typing import Any, Protocol, runtime_checkable
 
 from ..database import Database
-from ..load_file import load_file as _load_file
+from ..loadfile import load_file as _load_file
 
 
 @runtime_checkable

odxtools/cli/_print_utils.py

@@ -6,6 +6,7 @@ from typing import Any, Callable, Dict, List, Optional, Union
 import markdownify
 from tabulate import tabulate  # TODO: switch to rich tables
 
+from ..description import Description
 from ..diaglayer import DiagLayer
 from ..diagservice import DiagService
 from ..parameters.codedconstparameter import CodedConstParameter
@@ -17,9 +18,9 @@ from ..parameters.valueparameter import ValueParameter
 from ..singleecujob import SingleEcuJob
 
 
-def format_desc(desc: str, indent: int = 0) -> str:
+def format_desc(description: Description, indent: int = 0) -> str:
     # Collapse whitespaces
-    desc = re.sub(r"\s+", " ", desc)
+    desc = re.sub(r"\s+", " ", str(description))
     # Covert XHTML to Markdown
     desc = markdownify.markdownify(desc)
     # Collapse blank lines

odxtools/cli/compare.py

@@ -11,7 +11,7 @@ from tabulate import tabulate  # TODO: switch to rich tables
 from ..database import Database
 from ..diaglayer import DiagLayer
 from ..diagservice import DiagService
-from ..load_file import load_file
+from ..loadfile import load_file
 from ..odxtypes import AtomicOdxType
 from ..parameters.codedconstparameter import CodedConstParameter
 from ..parameters.nrcconstparameter import NrcConstParameter

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)

odxtools/comparaminstance.py

@@ -1,18 +1,16 @@
 # SPDX-License-Identifier: MIT
 import warnings
 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 .basecomparam import BaseComparam
 from .comparam import Comparam
 from .complexcomparam import ComplexComparam, ComplexValue, create_complex_value_from_et
+from .description import Description
 from .exceptions import OdxWarning, odxraise, odxrequire
 from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef
-from .utils import create_description_from_et
-
-if TYPE_CHECKING:
-    from .diaglayer import DiagLayer
+from .snrefcontext import SnRefContext
 
 
 @dataclass
@@ -23,7 +21,7 @@ class ComparamInstance:
     Be aware that the ODX specification calls this class COMPARAM-REF!
     """
     value: Union[str, ComplexValue]
-    description: Optional[str]
+    description: Optional[Description]
     protocol_snref: Optional[str]
     prot_stack_snref: Optional[str]
     spec_ref: OdxLinkRef
@@ -44,7 +42,7 @@ class ComparamInstance:
         else:
             value = create_complex_value_from_et(odxrequire(et_element.find("COMPLEX-VALUE")))
 
-        description = create_description_from_et(et_element.find("DESC"))
+        description = Description.from_et(et_element.find("DESC"), doc_frags)
 
         prot_stack_snref = None
         if (psnref_elem := et_element.find("PROT-STACK-SNREF")) is not None:
@@ -68,7 +66,7 @@ class ComparamInstance:
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
         self._spec = odxlinks.resolve(self.spec_ref, BaseComparam)
 
-    def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
         pass
 
     @property

odxtools/comparamspec.py

@@ -1,23 +1,19 @@
 # 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 .companydata import CompanyData
-from .createcompanydatas import create_company_datas_from_et
-from .createsdgs import create_sdgs_from_et
 from .element import IdentifiableElement
 from .exceptions import odxrequire
 from .nameditemlist import NamedItemList
 from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
 from .protstack import ProtStack
+from .snrefcontext import SnRefContext
 from .specialdatagroup import SpecialDataGroup
 from .utils import dataclass_fields_asdict
 
-if TYPE_CHECKING:
-    from .diaglayer import DiagLayer
-
 
 @dataclass
 class ComparamSpec(IdentifiableElement):
@@ -34,8 +30,13 @@ class ComparamSpec(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)
-        sdgs = create_sdgs_from_et(et_element.find("SDGS"), doc_frags)
+        company_datas = NamedItemList([
+            CompanyData.from_et(cde, doc_frags)
+            for cde in et_element.iterfind("COMPANY-DATAS/COMPANY-DATA")
+        ])
+        sdgs = [
+            SpecialDataGroup.from_et(sdge, doc_frags) for sdge in et_element.iterfind("SDGS/SDG")
+        ]
         prot_stacks = NamedItemList([
             ProtStack.from_et(dl_element, doc_frags)
             for dl_element in et_element.iterfind("PROT-STACKS/PROT-STACK")
@@ -80,15 +81,15 @@ class ComparamSpec(IdentifiableElement):
         for ps in self.prot_stacks:
             ps._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 cd in self.company_datas:
-            cd._resolve_snrefs(diag_layer)
+            cd._resolve_snrefs(context)
 
         for sdg in self.sdgs:
-            sdg._resolve_snrefs(diag_layer)
+            sdg._resolve_snrefs(context)
 
         for ps in self.prot_stacks:
-            ps._resolve_snrefs(diag_layer)
+            ps._resolve_snrefs(context)

odxtools/comparamsubset.py

@@ -1,26 +1,22 @@
 # 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 .companydata import CompanyData
 from .comparam import Comparam
 from .complexcomparam import ComplexComparam
-from .createcompanydatas import create_company_datas_from_et
-from .createsdgs import create_sdgs_from_et
 from .dataobjectproperty import DataObjectProperty
 from .element import IdentifiableElement
 from .exceptions import odxrequire
 from .nameditemlist import NamedItemList
 from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
+from .snrefcontext import SnRefContext
 from .specialdatagroup import SpecialDataGroup
 from .unitspec import UnitSpec
 from .utils import dataclass_fields_asdict
 
-if TYPE_CHECKING:
-    from .diaglayer import DiagLayer
-
 
 @dataclass
 class ComparamSubset(IdentifiableElement):
@@ -45,7 +41,10 @@ class ComparamSubset(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")
+        ])
 
         data_object_props = NamedItemList([
             DataObjectProperty.from_et(el, doc_frags)
@@ -62,7 +61,9 @@ class ComparamSubset(IdentifiableElement):
         else:
             unit_spec = None
 
-        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 ComparamSubset(
             category=category,
@@ -127,25 +128,25 @@ class ComparamSubset(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 dop in self.data_object_props:
-            dop._resolve_snrefs(diag_layer)
+            dop._resolve_snrefs(context)
 
         for comparam in self.comparams:
-            comparam._resolve_snrefs(diag_layer)
+            comparam._resolve_snrefs(context)
 
         for ccomparam in self.complex_comparams:
-            ccomparam._resolve_snrefs(diag_layer)
+            ccomparam._resolve_snrefs(context)
 
         if self.unit_spec:
-            self.unit_spec._resolve_snrefs(diag_layer)
+            self.unit_spec._resolve_snrefs(context)
 
         if self.admin_data is not None:
-            self.admin_data._resolve_snrefs(diag_layer)
+            self.admin_data._resolve_snrefs(context)
 
         if self.company_datas is not None:
             for cd in self.company_datas:
-                cd._resolve_snrefs(diag_layer)
+                cd._resolve_snrefs(context)
 
         for sdg in self.sdgs:
-            sdg._resolve_snrefs(diag_layer)
+            sdg._resolve_snrefs(context)