odxtools 10.0.0__py3-none-any.whl → 10.1.0__py3-none-any.whl

odxtools/diaglayers/protocolraw.py

@@ -1,20 +1,20 @@
 # SPDX-License-Identifier: MIT
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from typing import Any
 from xml.etree import ElementTree
 
 from ..comparamspec import ComparamSpec
 from ..exceptions import odxrequire
-from ..odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef, resolve_snref
+from ..odxdoccontext import OdxDocContext
+from ..odxlink import OdxLinkDatabase, OdxLinkId, OdxLinkRef, resolve_snref
 from ..parentref import ParentRef
 from ..protstack import ProtStack
 from ..snrefcontext import SnRefContext
 from ..utils import dataclass_fields_asdict
-#from .comparaminstance import ComparamInstance
 from .hierarchyelementraw import HierarchyElementRaw
 
 
-@dataclass
+@dataclass(kw_only=True)
 class ProtocolRaw(HierarchyElementRaw):
     """This is the base class for diagnostic layers that describe a
     protocol which can be used to communicate with an ECU
@@ -24,8 +24,8 @@ class ProtocolRaw(HierarchyElementRaw):
     """
 
     comparam_spec_ref: OdxLinkRef
-    prot_stack_snref: str | None
-    parent_refs: list[ParentRef]
+    prot_stack_snref: str | None = None
+    parent_refs: list[ParentRef] = field(default_factory=list)
 
     @property
     def comparam_spec(self) -> ComparamSpec:
@@ -36,24 +36,23 @@ class ProtocolRaw(HierarchyElementRaw):
         return self._prot_stack
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element, doc_frags: list[OdxDocFragment]) -> "ProtocolRaw":
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "ProtocolRaw":
         # 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.
-        her = HierarchyElementRaw.from_et(et_element, doc_frags)
+        her = HierarchyElementRaw.from_et(et_element, context)
         kwargs = dataclass_fields_asdict(her)
-        doc_frags = her.odx_id.doc_fragments
 
         comparam_spec_ref = OdxLinkRef.from_et(
-            odxrequire(et_element.find("COMPARAM-SPEC-REF")), doc_frags)
+            odxrequire(et_element.find("COMPARAM-SPEC-REF")), context)
 
         prot_stack_snref = 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"))
 
         parent_refs = [
-            ParentRef.from_et(pr_el, doc_frags)
+            ParentRef.from_et(pr_el, context)
             for pr_el in et_element.iterfind("PARENT-REFS/PARENT-REF")
         ]
 

odxtools/diagnostictroublecode.py

@@ -1,11 +1,12 @@
 # SPDX-License-Identifier: MIT
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from typing import Any
 from xml.etree import ElementTree
 
 from .element import IdentifiableElement
 from .exceptions import odxrequire
-from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkId
 from .odxtypes import odxstr_to_bool
 from .snrefcontext import SnRefContext
 from .specialdatagroup import SpecialDataGroup
@@ -13,34 +14,31 @@ from .text import Text
 from .utils import dataclass_fields_asdict
 
 
-@dataclass
+@dataclass(kw_only=True)
 class DiagnosticTroubleCode(IdentifiableElement):
     trouble_code: int
-    display_trouble_code: str | None
+    display_trouble_code: str | None = None
     text: Text
-    level: int | None
-    sdgs: list[SpecialDataGroup]
+    level: int | None = None
+    sdgs: list[SpecialDataGroup] = field(default_factory=list)
 
-    is_temporary_raw: bool | None
+    is_temporary_raw: bool | None = None
 
     @property
     def is_temporary(self) -> bool:
         return self.is_temporary_raw is True
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element,
-                doc_frags: list[OdxDocFragment]) -> "DiagnosticTroubleCode":
-        kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, doc_frags))
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "DiagnosticTroubleCode":
+        kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, context))
 
         trouble_code = int(odxrequire(et_element.findtext("TROUBLE-CODE")))
         display_trouble_code = et_element.findtext("DISPLAY-TROUBLE-CODE")
-        text = Text.from_et(odxrequire(et_element.find("TEXT")), doc_frags)
+        text = Text.from_et(odxrequire(et_element.find("TEXT")), context)
         level = None
         if (level_str := et_element.findtext("LEVEL")) is not None:
             level = int(level_str)
-        sdgs = [
-            SpecialDataGroup.from_et(sdge, doc_frags) for sdge in et_element.iterfind("SDGS/SDG")
-        ]
+        sdgs = [SpecialDataGroup.from_et(sdge, context) for sdge in et_element.iterfind("SDGS/SDG")]
 
         is_temporary_raw = odxstr_to_bool(et_element.attrib.get("IS-TEMPORARY"))
 

odxtools/diagservice.py

@@ -1,5 +1,5 @@
 # SPDX-License-Identifier: MIT
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from typing import Any, cast
 from xml.etree import ElementTree
 
@@ -9,7 +9,8 @@ from .diagcomm import DiagComm
 from .exceptions import DecodeError, DecodeMismatch, odxassert, odxraise, odxrequire
 from .message import Message
 from .nameditemlist import NamedItemList
-from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkId, OdxLinkRef
 from .odxtypes import ParameterValue, odxstr_to_bool
 from .parameters.parameter import Parameter
 from .posresponsesuppressible import PosResponseSuppressible
@@ -20,21 +21,21 @@ from .transmode import TransMode
 from .utils import dataclass_fields_asdict
 
 
-@dataclass
+@dataclass(kw_only=True)
 class DiagService(DiagComm):
     """Representation of a diagnostic service description.
     """
 
-    comparam_refs: list[ComparamInstance]
+    comparam_refs: list[ComparamInstance] = field(default_factory=list)
     request_ref: OdxLinkRef
-    pos_response_refs: list[OdxLinkRef]
-    neg_response_refs: list[OdxLinkRef]
-    pos_response_suppressible: PosResponseSuppressible | None
+    pos_response_refs: list[OdxLinkRef] = field(default_factory=list)
+    neg_response_refs: list[OdxLinkRef] = field(default_factory=list)
+    pos_response_suppressible: PosResponseSuppressible | None = None
 
-    is_cyclic_raw: bool | None
-    is_multiple_raw: bool | None
-    addressing_raw: Addressing | None
-    transmission_mode_raw: TransMode | None
+    is_cyclic_raw: bool | None = None
+    is_multiple_raw: bool | None = None
+    addressing_raw: Addressing | None = None
+    transmission_mode_raw: TransMode | None = None
 
     @property
     def comparams(self) -> NamedItemList[ComparamInstance]:
@@ -76,30 +77,30 @@ class DiagService(DiagComm):
         return self.request.free_parameters if self.request is not None else []
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element, doc_frags: list[OdxDocFragment]) -> "DiagService":
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "DiagService":
 
-        kwargs = dataclass_fields_asdict(DiagComm.from_et(et_element, doc_frags))
+        kwargs = dataclass_fields_asdict(DiagComm.from_et(et_element, context))
 
         comparam_refs = [
-            ComparamInstance.from_et(el, doc_frags)
+            ComparamInstance.from_et(el, context)
             for el in et_element.iterfind("COMPARAM-REFS/COMPARAM-REF")
         ]
 
-        request_ref = odxrequire(OdxLinkRef.from_et(et_element.find("REQUEST-REF"), doc_frags))
+        request_ref = odxrequire(OdxLinkRef.from_et(et_element.find("REQUEST-REF"), context))
 
         pos_response_refs = [
-            odxrequire(OdxLinkRef.from_et(el, doc_frags))
+            odxrequire(OdxLinkRef.from_et(el, context))
             for el in et_element.iterfind("POS-RESPONSE-REFS/POS-RESPONSE-REF")
         ]
 
         neg_response_refs = [
-            odxrequire(OdxLinkRef.from_et(el, doc_frags))
+            odxrequire(OdxLinkRef.from_et(el, context))
             for el in et_element.iterfind("NEG-RESPONSE-REFS/NEG-RESPONSE-REF")
         ]
 
         pos_response_suppressible = None
         if (prs_elem := et_element.find("POS-RESPONSE-SUPPRESSABLE")) is not None:
-            pos_response_suppressible = PosResponseSuppressible.from_et(prs_elem, doc_frags)
+            pos_response_suppressible = PosResponseSuppressible.from_et(prs_elem, context)
 
         is_cyclic_raw = odxstr_to_bool(et_element.get("IS-CYCLIC"))
         is_multiple_raw = odxstr_to_bool(et_element.get("IS-MULTIPLE"))

odxtools/diagvariable.py

@@ -1,6 +1,6 @@
 # SPDX-License-Identifier: MIT
 import typing
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from typing import Any, runtime_checkable
 from xml.etree import ElementTree
 
@@ -9,7 +9,8 @@ from .commrelation import CommRelation
 from .element import IdentifiableElement
 from .exceptions import odxrequire
 from .nameditemlist import NamedItemList
-from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef, resolve_snref
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkId, OdxLinkRef, resolve_snref
 from .odxtypes import odxstr_to_bool
 from .snrefcontext import SnRefContext
 from .specialdatagroup import SpecialDataGroup
@@ -28,26 +29,26 @@ class HasDiagVariables(typing.Protocol):
         ...
 
 
-@dataclass
+@dataclass(kw_only=True)
 class DiagVariable(IdentifiableElement):
     """Representation of a diagnostic variable
     """
 
-    admin_data: AdminData | None
-    variable_group_ref: OdxLinkRef | None
-    sw_variables: list[SwVariable]
+    admin_data: AdminData | None = None
+    variable_group_ref: OdxLinkRef | None = None
+    sw_variables: list[SwVariable] = field(default_factory=list)
 
     # a diag variable must specify either COMM-RELATIONS or a
     # reference to a table row
-    comm_relations: list[CommRelation]
+    comm_relations: list[CommRelation] = field(default_factory=list)
 
     # these are nested inside the SNREF-TO-TABLEROW tag
-    table_snref: str | None
-    table_row_snref: str | None
+    table_snref: str | None = None
+    table_row_snref: str | None = None
 
-    sdgs: list[SpecialDataGroup]
+    sdgs: list[SpecialDataGroup] = field(default_factory=list)
 
-    is_read_before_write_raw: bool | None
+    is_read_before_write_raw: bool | None = None
 
     @property
     def table(self) -> Table | None:
@@ -66,17 +67,17 @@ class DiagVariable(IdentifiableElement):
         return self.is_read_before_write_raw is True
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element, doc_frags: list[OdxDocFragment]) -> "DiagVariable":
-        kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, doc_frags))
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "DiagVariable":
+        kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, context))
 
-        admin_data = AdminData.from_et(et_element.find("ADMIN-DATA"), doc_frags)
-        variable_group_ref = OdxLinkRef.from_et(et_element.find("VARIABLE-GROUP-REF"), doc_frags)
+        admin_data = AdminData.from_et(et_element.find("ADMIN-DATA"), context)
+        variable_group_ref = OdxLinkRef.from_et(et_element.find("VARIABLE-GROUP-REF"), context)
         sw_variables = NamedItemList([
-            SwVariable.from_et(swv_elem, doc_frags)
+            SwVariable.from_et(swv_elem, context)
             for swv_elem in et_element.iterfind("SW-VARIABLES/SW-VARIABLE")
         ])
         comm_relations = [
-            CommRelation.from_et(cr_elem, doc_frags)
+            CommRelation.from_et(cr_elem, context)
             for cr_elem in et_element.iterfind("COMM-RELATIONS/COMM-RELATION")
         ]
 
@@ -89,9 +90,7 @@ class DiagVariable(IdentifiableElement):
             table_row_snref_elem = odxrequire(snref_to_tablerow_elem.find("TABLE-ROW-SNREF"))
             table_row_snref = odxrequire(table_row_snref_elem.attrib.get("SHORT-NAME"))
 
-        sdgs = [
-            SpecialDataGroup.from_et(sdge, doc_frags) for sdge in et_element.iterfind("SDGS/SDG")
-        ]
+        sdgs = [SpecialDataGroup.from_et(sdge, context) for sdge in et_element.iterfind("SDGS/SDG")]
 
         is_read_before_write_raw = odxstr_to_bool(et_element.get("IS-READ-BEFORE-WRITE"))
 

odxtools/docrevision.py

@@ -1,51 +1,52 @@
 # SPDX-License-Identifier: MIT
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from typing import Any
 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 .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkId, OdxLinkRef
 from .snrefcontext import SnRefContext
 from .teammember import TeamMember
 
 
-@dataclass
+@dataclass(kw_only=True)
 class DocRevision:
     """
     Representation of a single revision of the relevant object.
     """
 
-    team_member_ref: OdxLinkRef | None
-    revision_label: str | None
-    state: str | None
+    team_member_ref: OdxLinkRef | None = None
+    revision_label: str | None = None
+    state: str | None = None
     date: str
-    tool: str | None
-    company_revision_infos: list[CompanyRevisionInfo]
-    modifications: list[Modification]
+    tool: str | None = None
+    company_revision_infos: list[CompanyRevisionInfo] = field(default_factory=list)
+    modifications: list[Modification] = field(default_factory=list)
 
     @property
     def team_member(self) -> TeamMember | None:
         return self._team_member
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element, doc_frags: list[OdxDocFragment]) -> "DocRevision":
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "DocRevision":
 
-        team_member_ref = OdxLinkRef.from_et(et_element.find("TEAM-MEMBER-REF"), doc_frags)
+        team_member_ref = OdxLinkRef.from_et(et_element.find("TEAM-MEMBER-REF"), context)
         revision_label = et_element.findtext("REVISION-LABEL")
         state = et_element.findtext("STATE")
         date = odxrequire(et_element.findtext("DATE"))
         tool = et_element.findtext("TOOL")
 
         company_revision_infos = [
-            CompanyRevisionInfo.from_et(cri_elem, doc_frags)
+            CompanyRevisionInfo.from_et(cri_elem, context)
             for cri_elem in et_element.iterfind("COMPANY-REVISION-INFOS/"
                                                 "COMPANY-REVISION-INFO")
         ]
 
         modifications = [
-            Modification.from_et(mod_elem, doc_frags)
+            Modification.from_et(mod_elem, context)
             for mod_elem in et_element.iterfind("MODIFICATIONS/MODIFICATION")
         ]
 

odxtools/dopbase.py

@@ -1,5 +1,5 @@
 # SPDX-License-Identifier: MIT
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from typing import Any
 from xml.etree import ElementTree
 
@@ -7,14 +7,15 @@ from .admindata import AdminData
 from .decodestate import DecodeState
 from .element import IdentifiableElement
 from .encodestate import EncodeState
-from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkId
 from .odxtypes import ParameterValue
 from .snrefcontext import SnRefContext
 from .specialdatagroup import SpecialDataGroup
 from .utils import dataclass_fields_asdict
 
 
-@dataclass
+@dataclass(kw_only=True)
 class DopBase(IdentifiableElement):
     """Base class for all (simple and complex) data object properties.
 
@@ -24,21 +25,19 @@ class DopBase(IdentifiableElement):
 
     """
 
-    admin_data: AdminData | None
-    sdgs: list[SpecialDataGroup]
+    admin_data: AdminData | None = None
+    sdgs: list[SpecialDataGroup] = field(default_factory=list)
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element, doc_frags: list[OdxDocFragment]) -> "DopBase":
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "DopBase":
 
-        kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, doc_frags))
+        kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, context))
 
         admin_data = None
         if (admin_data_elem := et_element.find("ADMIN-DATA")) is not None:
-            admin_data = AdminData.from_et(admin_data_elem, doc_frags)
+            admin_data = AdminData.from_et(admin_data_elem, context)
 
-        sdgs = [
-            SpecialDataGroup.from_et(sdge, doc_frags) for sdge in et_element.iterfind("SDGS/SDG")
-        ]
+        sdgs = [SpecialDataGroup.from_et(sdge, context) for sdge in et_element.iterfind("SDGS/SDG")]
 
         return DopBase(admin_data=admin_data, sdgs=sdgs, **kwargs)
 

odxtools/dtcconnector.py

@@ -7,12 +7,13 @@ from .diagnostictroublecode import DiagnosticTroubleCode
 from .dtcdop import DtcDop
 from .element import NamedElement
 from .exceptions import odxrequire
-from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef, resolve_snref
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkId, OdxLinkRef, resolve_snref
 from .snrefcontext import SnRefContext
 from .utils import dataclass_fields_asdict
 
 
-@dataclass
+@dataclass(kw_only=True)
 class DtcConnector(NamedElement):
     dtc_dop_ref: OdxLinkRef
     dtc_snref: str
@@ -26,10 +27,10 @@ class DtcConnector(NamedElement):
         return self._dtc
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element, doc_frags: list[OdxDocFragment]) -> "DtcConnector":
-        kwargs = dataclass_fields_asdict(NamedElement.from_et(et_element, doc_frags))
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "DtcConnector":
+        kwargs = dataclass_fields_asdict(NamedElement.from_et(et_element, context))
 
-        dtc_dop_ref = odxrequire(OdxLinkRef.from_et(et_element.find("DTC-DOP-REF"), doc_frags))
+        dtc_dop_ref = odxrequire(OdxLinkRef.from_et(et_element.find("DTC-DOP-REF"), context))
         dtc_snref_el = odxrequire(et_element.find("DTC-SNREF"))
         dtc_snref = odxrequire(dtc_snref_el.get("SHORT-NAME"))
 

odxtools/dtcdop.py

@@ -1,5 +1,5 @@
 # SPDX-License-Identifier: MIT
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from typing import Any, cast
 from xml.etree import ElementTree
 
@@ -16,23 +16,24 @@ from .encodestate import EncodeState
 from .exceptions import DecodeError, EncodeError, odxassert, odxraise, odxrequire
 from .linkeddtcdop import LinkedDtcDop
 from .nameditemlist import NamedItemList
-from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkId, OdxLinkRef
 from .odxtypes import ParameterValue, odxstr_to_bool
 from .physicaltype import PhysicalType
 from .snrefcontext import SnRefContext
 from .utils import dataclass_fields_asdict
 
 
-@dataclass
+@dataclass(kw_only=True)
 class DtcDop(DopBase):
     """A DOP describing a diagnostic trouble code"""
 
     diag_coded_type: DiagCodedType
     physical_type: PhysicalType
     compu_method: CompuMethod
-    dtcs_raw: list[DiagnosticTroubleCode | OdxLinkRef]
-    linked_dtc_dops_raw: list[LinkedDtcDop]
-    is_visible_raw: bool | None
+    dtcs_raw: list[DiagnosticTroubleCode | OdxLinkRef] = field(default_factory=list)
+    linked_dtc_dops_raw: list[LinkedDtcDop] = field(default_factory=list)
+    is_visible_raw: bool | None = None
 
     @property
     def dtcs(self) -> NamedItemList[DiagnosticTroubleCode]:
@@ -47,17 +48,16 @@ class DtcDop(DopBase):
         return self.is_visible_raw is True
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element, doc_frags: list[OdxDocFragment]) -> "DtcDop":
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "DtcDop":
         """Reads a DTC-DOP."""
-        kwargs = dataclass_fields_asdict(DopBase.from_et(et_element, doc_frags))
+        kwargs = dataclass_fields_asdict(DopBase.from_et(et_element, context))
 
         diag_coded_type = create_any_diag_coded_type_from_et(
-            odxrequire(et_element.find("DIAG-CODED-TYPE")), doc_frags)
-        physical_type = PhysicalType.from_et(
-            odxrequire(et_element.find("PHYSICAL-TYPE")), doc_frags)
+            odxrequire(et_element.find("DIAG-CODED-TYPE")), context)
+        physical_type = PhysicalType.from_et(odxrequire(et_element.find("PHYSICAL-TYPE")), context)
         compu_method = create_any_compu_method_from_et(
             odxrequire(et_element.find("COMPU-METHOD")),
-            doc_frags,
+            context,
             internal_type=diag_coded_type.base_data_type,
             physical_type=physical_type.base_data_type,
         )
@@ -65,12 +65,12 @@ class DtcDop(DopBase):
         if (dtcs_elem := et_element.find("DTCS")) is not None:
             for dtc_proxy_elem in dtcs_elem:
                 if dtc_proxy_elem.tag == "DTC":
-                    dtcs_raw.append(DiagnosticTroubleCode.from_et(dtc_proxy_elem, doc_frags))
+                    dtcs_raw.append(DiagnosticTroubleCode.from_et(dtc_proxy_elem, context))
                 elif dtc_proxy_elem.tag == "DTC-REF":
-                    dtcs_raw.append(OdxLinkRef.from_et(dtc_proxy_elem, doc_frags))
+                    dtcs_raw.append(OdxLinkRef.from_et(dtc_proxy_elem, context))
 
         linked_dtc_dops_raw = [
-            LinkedDtcDop.from_et(dtc_ref_elem, doc_frags)
+            LinkedDtcDop.from_et(dtc_ref_elem, context)
             for dtc_ref_elem in et_element.iterfind("LINKED-DTC-DOPS/"
                                                     "LINKED-DTC-DOP")
         ]

odxtools/dynamicendmarkerfield.py

@@ -12,13 +12,14 @@ from .dynenddopref import DynEndDopRef
 from .encodestate import EncodeState
 from .exceptions import DecodeError, EncodeError, odxassert, odxraise, odxrequire
 from .field import Field
-from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkId
 from .odxtypes import AtomicOdxType, ParameterValue
 from .snrefcontext import SnRefContext
 from .utils import dataclass_fields_asdict
 
 
-@dataclass
+@dataclass(kw_only=True)
 class DynamicEndmarkerField(Field):
     """Array of a structure with variable length determined by a termination sequence"""
 
@@ -33,14 +34,13 @@ class DynamicEndmarkerField(Field):
         return self._termination_value
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element,
-                doc_frags: list[OdxDocFragment]) -> "DynamicEndmarkerField":
-        kwargs = dataclass_fields_asdict(Field.from_et(et_element, doc_frags))
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "DynamicEndmarkerField":
+        kwargs = dataclass_fields_asdict(Field.from_et(et_element, context))
 
         # ODX 2.0 uses DATA-OBJECT-PROP-REF
         # ODX 2.2 uses DYN-END-DOP-REF
         dop_ref = et_element.find("DYN-END-DOP-REF") or et_element.find("DATA-OBJECT-PROP-REF")
-        dyn_end_dop_ref = DynEndDopRef.from_et(odxrequire(dop_ref), doc_frags)
+        dyn_end_dop_ref = DynEndDopRef.from_et(odxrequire(dop_ref), context)
 
         return DynamicEndmarkerField(dyn_end_dop_ref=dyn_end_dop_ref, **kwargs)
 

odxtools/dynamiclengthfield.py

@@ -11,27 +11,27 @@ from .determinenumberofitems import DetermineNumberOfItems
 from .encodestate import EncodeState
 from .exceptions import DecodeError, EncodeError, odxassert, odxraise, odxrequire
 from .field import Field
-from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkId
 from .odxtypes import ParameterValue
 from .snrefcontext import SnRefContext
 from .utils import dataclass_fields_asdict
 
 
-@dataclass
+@dataclass(kw_only=True)
 class DynamicLengthField(Field):
     """Array of structure with length field"""
     offset: int
     determine_number_of_items: DetermineNumberOfItems
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element,
-                doc_frags: list[OdxDocFragment]) -> "DynamicLengthField":
-        kwargs = dataclass_fields_asdict(Field.from_et(et_element, doc_frags))
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "DynamicLengthField":
+        kwargs = dataclass_fields_asdict(Field.from_et(et_element, context))
 
         offset = int(odxrequire(et_element.findtext('OFFSET')))
         determine_number_of_items = DetermineNumberOfItems.from_et(
             odxrequire(et_element.find('DETERMINE-NUMBER-OF-ITEMS')),
-            doc_frags,
+            context,
         )
 
         return DynamicLengthField(

odxtools/dyndefinedspec.py

@@ -1,22 +1,22 @@
 # SPDX-License-Identifier: MIT
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from typing import Any
 from xml.etree import ElementTree
 
 from .dyniddefmodeinfo import DynIdDefModeInfo
-from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkId
 from .snrefcontext import SnRefContext
 
 
-@dataclass
+@dataclass(kw_only=True)
 class DynDefinedSpec:
-    dyn_id_def_mode_infos: list[DynIdDefModeInfo]
+    dyn_id_def_mode_infos: list[DynIdDefModeInfo] = field(default_factory=list)
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element,
-                doc_frags: list[OdxDocFragment]) -> "DynDefinedSpec":
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "DynDefinedSpec":
         dyn_id_def_mode_infos = [
-            DynIdDefModeInfo.from_et(x, doc_frags)
+            DynIdDefModeInfo.from_et(x, context)
             for x in et_element.iterfind("DYN-ID-DEF-MODE-INFOS/DYN-ID-DEF-MODE-INFO")
         ]
         return DynDefinedSpec(dyn_id_def_mode_infos=dyn_id_def_mode_infos)