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

odxtools/diaglayers/hierarchyelement.py

@@ -17,7 +17,8 @@ from ..diagservice import DiagService
 from ..exceptions import OdxWarning, odxassert, odxraise
 from ..functionalclass import FunctionalClass
 from ..nameditemlist import NamedItemList, OdxNamed
-from ..odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
+from ..odxdoccontext import OdxDocContext
+from ..odxlink import OdxLinkDatabase, OdxLinkId
 from ..parentref import ParentRef
 from ..response import Response
 from ..singleecujob import SingleEcuJob
@@ -30,13 +31,13 @@ from .diaglayer import DiagLayer
 from .hierarchyelementraw import HierarchyElementRaw
 
 if TYPE_CHECKING:
-    from .database import Database
+    from ..database import Database
     from .protocol import Protocol
 
 TNamed = TypeVar("TNamed", bound=OdxNamed)
 
 
-@dataclass
+@dataclass(kw_only=True)
 class HierarchyElement(DiagLayer):
     """This is the base class for diagnostic layers that may be involved in value inheritance
     """
@@ -46,9 +47,8 @@ class HierarchyElement(DiagLayer):
         return cast(HierarchyElementRaw, self.diag_layer_raw)
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element,
-                doc_frags: list[OdxDocFragment]) -> "HierarchyElement":
-        hierarchy_element_raw = HierarchyElementRaw.from_et(et_element, doc_frags)
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "HierarchyElement":
+        hierarchy_element_raw = HierarchyElementRaw.from_et(et_element, context)
 
         return HierarchyElement(diag_layer_raw=hierarchy_element_raw)
 
@@ -121,13 +121,13 @@ class HierarchyElement(DiagLayer):
         unit_groups = self._compute_available_unit_groups()
 
         # convenience variable for the locally-defined unit spec
-        local_unit_spec: UnitSpec | None
+        local_unit_spec: UnitSpec | None = None
         if self.diag_layer_raw.diag_data_dictionary_spec is not None:
             local_unit_spec = self.diag_layer_raw.diag_data_dictionary_spec.unit_spec
         else:
             local_unit_spec = None
 
-        unit_spec: UnitSpec | None
+        unit_spec: UnitSpec | None = None
         if local_unit_spec is None and not unit_groups:
             # no locally defined unit spec and no inherited unit groups
             unit_spec = None
@@ -587,7 +587,7 @@ class HierarchyElement(DiagLayer):
 
         from .protocol import Protocol
 
-        protocol_name: str | None
+        protocol_name: str | None = None
         if isinstance(protocol, Protocol):
             protocol_name = protocol.short_name
         else:

odxtools/diaglayers/hierarchyelementraw.py

@@ -1,37 +1,36 @@
 # SPDX-License-Identifier: MIT
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from typing import Any
 from xml.etree import ElementTree
 
 from ..comparaminstance import ComparamInstance
-from ..odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
+from ..odxdoccontext import OdxDocContext
+from ..odxlink import OdxLinkDatabase, OdxLinkId
 from ..snrefcontext import SnRefContext
 from ..utils import dataclass_fields_asdict
 from .diaglayerraw import DiagLayerRaw
 
 
-@dataclass
+@dataclass(kw_only=True)
 class HierarchyElementRaw(DiagLayerRaw):
     """This is the base class for diagnostic layers that may be involved in value inheritance
 
     This class represents the data present in the XML, not the "logical" view.
     """
 
-    comparam_refs: list[ComparamInstance]
+    comparam_refs: list[ComparamInstance] = field(default_factory=list)
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element,
-                doc_frags: list[OdxDocFragment]) -> "HierarchyElementRaw":
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "HierarchyElementRaw":
         # objects contained by diagnostic layers exibit an additional
         # document fragment for the diag layer, so we use the document
         # fragments of the odx id of the diag layer for IDs of
         # contained objects.
-        dlr = DiagLayerRaw.from_et(et_element, doc_frags)
+        dlr = DiagLayerRaw.from_et(et_element, context)
         kwargs = dataclass_fields_asdict(dlr)
-        doc_frags = dlr.odx_id.doc_fragments
 
         comparam_refs = [
-            ComparamInstance.from_et(el, doc_frags)
+            ComparamInstance.from_et(el, context)
             for el in et_element.iterfind("COMPARAM-REFS/COMPARAM-REF")
         ]
 

odxtools/diaglayers/protocol.py

@@ -6,13 +6,13 @@ from xml.etree import ElementTree
 
 from ..comparamspec import ComparamSpec
 from ..exceptions import odxassert
-from ..odxlink import OdxDocFragment
+from ..odxdoccontext import OdxDocContext
 from ..protstack import ProtStack
 from .hierarchyelement import HierarchyElement
 from .protocolraw import ProtocolRaw
 
 
-@dataclass
+@dataclass(kw_only=True)
 class Protocol(HierarchyElement):
     """This is the class for primitives that are common for a given communication protocol
 
@@ -33,8 +33,8 @@ class Protocol(HierarchyElement):
         return self.protocol_raw.prot_stack
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element, doc_frags: list[OdxDocFragment]) -> "Protocol":
-        protocol_raw = ProtocolRaw.from_et(et_element, doc_frags)
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "Protocol":
+        protocol_raw = ProtocolRaw.from_et(et_element, context)
 
         return Protocol(diag_layer_raw=protocol_raw)
 

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")
         ]