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

odxtools/diagnostictroublecode.py

@@ -1,11 +1,12 @@
 # SPDX-License-Identifier: MIT
-from dataclasses import dataclass
-from typing import Any, Dict, List, Optional
+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: Optional[str]
+    display_trouble_code: str | None = None
     text: Text
-    level: Optional[int]
-    sdgs: List[SpecialDataGroup]
+    level: int | None = None
+    sdgs: list[SpecialDataGroup] = field(default_factory=list)
 
-    is_temporary_raw: Optional[bool]
+    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"))
 
@@ -53,8 +51,8 @@ class DiagnosticTroubleCode(IdentifiableElement):
             is_temporary_raw=is_temporary_raw,
             **kwargs)
 
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
-        result: Dict[OdxLinkId, Any] = {}
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
+        result: dict[OdxLinkId, Any] = {}
 
         result[self.odx_id] = self
 

odxtools/diagservice.py

@@ -1,6 +1,6 @@
 # SPDX-License-Identifier: MIT
-from dataclasses import dataclass
-from typing import Any, Dict, List, Optional, Union, cast
+from dataclasses import dataclass, field
+from typing import Any, cast
 from xml.etree import ElementTree
 
 from .addressing import Addressing
@@ -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,28 +21,28 @@ 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: Optional[PosResponseSuppressible]
+    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: Optional[bool]
-    is_multiple_raw: Optional[bool]
-    addressing_raw: Optional[Addressing]
-    transmission_mode_raw: Optional[TransMode]
+    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]:
         return self._comparams
 
     @property
-    def request(self) -> Optional[Request]:
+    def request(self) -> Request | None:
         return self._request
 
     @property
@@ -69,42 +70,42 @@ class DiagService(DiagComm):
         return self.transmission_mode_raw or TransMode.SEND_AND_RECEIVE
 
     @property
-    def free_parameters(self) -> List[Parameter]:
+    def free_parameters(self) -> list[Parameter]:
         """Return the list of parameters which can be freely specified by
         the user when encoding the service's request.
         """
         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"))
 
-        addressing_raw: Optional[Addressing] = None
+        addressing_raw: Addressing | None = None
         if (addressing_raw_str := et_element.get("ADDRESSING")) is not None:
             try:
                 addressing_raw = Addressing(addressing_raw_str)
@@ -112,7 +113,7 @@ class DiagService(DiagComm):
                 addressing_raw = cast(Addressing, None)
                 odxraise(f"Encountered unknown addressing type '{addressing_raw_str}'")
 
-        transmission_mode_raw: Optional[TransMode] = None
+        transmission_mode_raw: TransMode | None = None
         if (transmission_mode_raw_str := et_element.get("TRANSMISSION-MODE")) is not None:
             try:
                 transmission_mode_raw = TransMode(transmission_mode_raw_str)
@@ -132,7 +133,7 @@ class DiagService(DiagComm):
             transmission_mode_raw=transmission_mode_raw,
             **kwargs)
 
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         result = super()._build_odxlinks()
 
         for cpr in self.comparam_refs:
@@ -180,20 +181,20 @@ class DiagService(DiagComm):
 
     def decode_message(self, raw_message: bytes) -> Message:
         request_prefix = b''
-        candidate_coding_objects: List[Union[Request, Response]] = [
+        candidate_coding_objects: list[Request | Response] = [
             *self.positive_responses, *self.negative_responses
         ]
         if self.request is not None:
             request_prefix = self.request.coded_const_prefix()
             candidate_coding_objects.append(self.request)
 
-        coding_objects: List[Union[Request, Response]] = []
+        coding_objects: list[Request | Response] = []
         for candidate_coding_object in candidate_coding_objects:
             prefix = candidate_coding_object.coded_const_prefix(request_prefix=request_prefix)
             if len(raw_message) >= len(prefix) and prefix == raw_message[:len(prefix)]:
                 coding_objects.append(candidate_coding_object)
 
-        result_list: List[Message] = []
+        result_list: list[Message] = []
         for coding_object in coding_objects:
             try:
                 result_list.append(

odxtools/diagvariable.py

@@ -1,7 +1,7 @@
 # SPDX-License-Identifier: MIT
 import typing
-from dataclasses import dataclass
-from typing import Any, Dict, List, Optional, runtime_checkable
+from dataclasses import dataclass, field
+from typing import Any, runtime_checkable
 from xml.etree import ElementTree
 
 from .admindata import AdminData
@@ -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,37 +29,37 @@ class HasDiagVariables(typing.Protocol):
         ...
 
 
-@dataclass
+@dataclass(kw_only=True)
 class DiagVariable(IdentifiableElement):
     """Representation of a diagnostic variable
     """
 
-    admin_data: Optional[AdminData]
-    variable_group_ref: Optional[OdxLinkRef]
-    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: Optional[str]
-    table_row_snref: Optional[str]
+    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: Optional[bool]
+    is_read_before_write_raw: bool | None = None
 
     @property
-    def table(self) -> Optional[Table]:
+    def table(self) -> Table | None:
         return self._table
 
     @property
-    def table_row(self) -> Optional[TableRow]:
+    def table_row(self) -> TableRow | None:
         return self._table_row
 
     @property
-    def variable_group(self) -> Optional[VariableGroup]:
+    def variable_group(self) -> VariableGroup | None:
         return self._variable_group
 
     @property
@@ -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"))
 
@@ -106,7 +105,7 @@ class DiagVariable(IdentifiableElement):
             is_read_before_write_raw=is_read_before_write_raw,
             **kwargs)
 
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         result = {self.odx_id: self}
 
         if self.admin_data is not None:

odxtools/docrevision.py

@@ -1,51 +1,52 @@
 # SPDX-License-Identifier: MIT
-from dataclasses import dataclass
-from typing import Any, Dict, List, Optional
+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: Optional[OdxLinkRef]
-    revision_label: Optional[str]
-    state: Optional[str]
+    team_member_ref: OdxLinkRef | None = None
+    revision_label: str | None = None
+    state: str | None = None
     date: str
-    tool: Optional[str]
-    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) -> Optional[TeamMember]:
+    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")
         ]
 
@@ -59,11 +60,11 @@ class DocRevision:
             modifications=modifications,
         )
 
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         return {}
 
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
-        self._team_member: Optional[TeamMember] = None
+        self._team_member: TeamMember | None = None
         if self.team_member_ref is not None:
             self._team_member = odxlinks.resolve(self.team_member_ref, TeamMember)
 

odxtools/dopbase.py

@@ -1,20 +1,21 @@
 # SPDX-License-Identifier: MIT
-from dataclasses import dataclass
-from typing import Any, Dict, List, Optional
+from dataclasses import dataclass, field
+from typing import Any
 from xml.etree import ElementTree
 
 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,25 +25,23 @@ class DopBase(IdentifiableElement):
 
     """
 
-    admin_data: Optional[AdminData]
-    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)
 
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         result = {self.odx_id: self}
 
         for sdg in self.sdgs:
@@ -58,7 +57,7 @@ class DopBase(IdentifiableElement):
         for sdg in self.sdgs:
             sdg._resolve_snrefs(context)
 
-    def get_static_bit_length(self) -> Optional[int]:
+    def get_static_bit_length(self) -> int | None:
         return None
 
     def is_valid_physical_value(self, physical_value: ParameterValue) -> bool:

odxtools/dtcconnector.py

@@ -1,18 +1,19 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import Any, Dict, List
+from typing import Any
 from xml.etree import ElementTree
 
 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,16 +27,16 @@ 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"))
 
         return DtcConnector(dtc_dop_ref=dtc_dop_ref, dtc_snref=dtc_snref, **kwargs)
 
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         return {}
 
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:

odxtools/dtcdop.py

@@ -1,6 +1,6 @@
 # SPDX-License-Identifier: MIT
-from dataclasses import dataclass
-from typing import Any, Dict, List, Optional, Union, cast
+from dataclasses import dataclass, field
+from typing import Any, cast
 from xml.etree import ElementTree
 
 from typing_extensions import override
@@ -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[Union[DiagnosticTroubleCode, OdxLinkRef]]
-    linked_dtc_dops_raw: List[LinkedDtcDop]
-    is_visible_raw: Optional[bool]
+    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,30 +48,29 @@ 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,
         )
-        dtcs_raw: List[Union[DiagnosticTroubleCode, OdxLinkRef]] = []
+        dtcs_raw: list[DiagnosticTroubleCode | OdxLinkRef] = []
         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")
         ]
@@ -155,7 +155,7 @@ class DtcDop(DopBase):
             return cast(int, None)
 
     @override
-    def encode_into_pdu(self, physical_value: Optional[ParameterValue],
+    def encode_into_pdu(self, physical_value: ParameterValue | None,
                         encode_state: EncodeState) -> None:
         if physical_value is None:
             odxraise(f"No DTC specified", EncodeError)
@@ -163,7 +163,11 @@ class DtcDop(DopBase):
 
         trouble_code = self.convert_to_numerical_trouble_code(physical_value)
 
-        internal_trouble_code = int(self.compu_method.convert_physical_to_internal(trouble_code))
+        if not isinstance(trouble_code, int):
+            odxraise()
+        internal_trouble_code = self.compu_method.convert_physical_to_internal(trouble_code)
+        if not isinstance(internal_trouble_code, int):
+            odxraise()
 
         found = False
         for dtc in self.dtcs:
@@ -178,7 +182,7 @@ class DtcDop(DopBase):
 
         self.diag_coded_type.encode_into_pdu(internal_trouble_code, encode_state)
 
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         odxlinks = super()._build_odxlinks()
 
         odxlinks.update(self.compu_method._build_odxlinks())