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

odxtools/environmentdatadescription.py

@@ -1,6 +1,6 @@
 # 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 typing_extensions import override
@@ -13,7 +13,8 @@ from .encodestate import EncodeState
 from .environmentdata import EnvironmentData
 from .exceptions import odxraise, odxrequire
 from .nameditemlist import NamedItemList
-from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkId, OdxLinkRef
 from .odxtypes import DataType, ParameterValue, ParameterValueDict
 from .parameters.codedconstparameter import CodedConstParameter
 from .parameters.parameter import Parameter
@@ -24,7 +25,7 @@ from .snrefcontext import SnRefContext
 from .utils import dataclass_fields_asdict
 
 
-@dataclass
+@dataclass(kw_only=True)
 class EnvironmentDataDescription(ComplexDop):
     """This class represents environment data descriptions
 
@@ -35,20 +36,20 @@ class EnvironmentDataDescription(ComplexDop):
 
     """
 
-    param_snref: Optional[str]
-    param_snpathref: Optional[str]
+    param_snref: str | None = None
+    param_snpathref: str | None = None
 
     # in ODX 2.0.0, ENV-DATAS seems to be a mandatory
     # sub-element of ENV-DATA-DESC, in ODX 2.2 it is not
     # present
-    env_datas: NamedItemList[EnvironmentData]
-    env_data_refs: List[OdxLinkRef]
+    env_datas: NamedItemList[EnvironmentData] = field(default_factory=NamedItemList)
+    env_data_refs: list[OdxLinkRef] = field(default_factory=list)
 
     @staticmethod
     def from_et(et_element: ElementTree.Element,
-                doc_frags: List[OdxDocFragment]) -> "EnvironmentDataDescription":
+                context: OdxDocContext) -> "EnvironmentDataDescription":
         """Reads Environment Data Description from Diag Layer."""
-        kwargs = dataclass_fields_asdict(ComplexDop.from_et(et_element, doc_frags))
+        kwargs = dataclass_fields_asdict(ComplexDop.from_et(et_element, context))
 
         param_snref = None
         if (param_snref_elem := et_element.find("PARAM-SNREF")) is not None:
@@ -63,11 +64,11 @@ class EnvironmentDataDescription(ComplexDop):
         # empty and one non-empty list here. (Which is which depends
         # on the version of the standard used by the file.)
         env_datas = NamedItemList([
-            EnvironmentData.from_et(env_data_elem, doc_frags)
+            EnvironmentData.from_et(env_data_elem, context)
             for env_data_elem in et_element.iterfind("ENV-DATAS/ENV-DATA")
         ])
         env_data_refs = [
-            odxrequire(OdxLinkRef.from_et(env_data_ref, doc_frags))
+            odxrequire(OdxLinkRef.from_et(env_data_ref, context))
             for env_data_ref in et_element.iterfind("ENV-DATA-REFS/ENV-DATA-REF")
         ]
 
@@ -78,7 +79,7 @@ class EnvironmentDataDescription(ComplexDop):
             env_data_refs=env_data_refs,
             **kwargs)
 
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         odxlinks = {self.odx_id: self}
 
         if not self.env_data_refs:
@@ -105,7 +106,7 @@ class EnvironmentDataDescription(ComplexDop):
                 ed._resolve_snrefs(context)
 
     @override
-    def encode_into_pdu(self, physical_value: Optional[ParameterValue],
+    def encode_into_pdu(self, physical_value: ParameterValue | None,
                         encode_state: EncodeState) -> None:
         """Convert a physical value into bytes and emplace them into a PDU.
         """
@@ -118,7 +119,7 @@ class EnvironmentDataDescription(ComplexDop):
                      "descriptions via SNPATHREF is not supported yet")
             return None
 
-        numerical_dtc_value: Optional[ParameterValue] = None
+        numerical_dtc_value: ParameterValue | None = None
         for prev_param, prev_param_value in reversed(encode_state.journal):
             if prev_param.short_name == self.param_snref:
                 numerical_dtc_value = self._get_numerical_dtc_from_parameter(
@@ -165,7 +166,7 @@ class EnvironmentDataDescription(ComplexDop):
                      "descriptions via SNPATHREF is not supported yet")
             return None
 
-        numerical_dtc_value: Optional[ParameterValue] = None
+        numerical_dtc_value: ParameterValue | None = None
         for prev_param, prev_param_value in reversed(decode_state.journal):
             if prev_param.short_name == self.param_snref:
                 numerical_dtc_value = self._get_numerical_dtc_from_parameter(
@@ -204,7 +205,7 @@ class EnvironmentDataDescription(ComplexDop):
         return result
 
     def _get_numerical_dtc_from_parameter(self, param: Parameter,
-                                          param_value: Optional[ParameterValue]) -> int:
+                                          param_value: ParameterValue | None) -> int:
         if isinstance(param, ParameterWithDOP):
             dop = param.dop
             if not isinstance(dop, (DataObjectProperty, DtcDop)):

odxtools/exceptions.py

@@ -1,5 +1,5 @@
 # SPDX-License-Identifier: MIT
-from typing import TYPE_CHECKING, NoReturn, Optional, Type, TypeVar
+from typing import TYPE_CHECKING, NoReturn, TypeVar
 
 from .globals import logger
 
@@ -37,7 +37,7 @@ class OdxWarning(Warning):
 strict_mode = True
 
 
-def odxraise(message: Optional[str] = None, error_type: Type[Exception] = OdxError) -> NoReturn:
+def odxraise(message: str | None = None, error_type: type[Exception] = OdxError) -> NoReturn:
     """
     Raise an exception but only if in strict mode.
 
@@ -53,8 +53,8 @@ def odxraise(message: Optional[str] = None, error_type: Type[Exception] = OdxErr
 
 
 def odxassert(condition: bool,
-              message: Optional[str] = None,
-              error_type: Type[Exception] = OdxError) -> None:
+              message: str | None = None,
+              error_type: type[Exception] = OdxError) -> None:
     """
     This method works similar as the build-in `assert` statement
 
@@ -72,7 +72,7 @@ def odxassert(condition: bool,
 T = TypeVar("T")
 
 
-def odxrequire(obj: Optional[T], message: Optional[str] = None) -> T:
+def odxrequire(obj: T | None, message: str | None = None) -> T:
     """This function ensures that an object required by the ODX
     specification is actually present.
 

odxtools/externalaccessmethod.py

@@ -1,22 +1,20 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import List
 from xml.etree import ElementTree
 
 from .element import IdentifiableElement
 from .exceptions import odxrequire
-from .odxlink import OdxDocFragment
+from .odxdoccontext import OdxDocContext
 from .utils import dataclass_fields_asdict
 
 
-@dataclass
+@dataclass(kw_only=True)
 class ExternalAccessMethod(IdentifiableElement):
     method: str
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element,
-                doc_frags: List[OdxDocFragment]) -> "ExternalAccessMethod":
-        kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, doc_frags))
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "ExternalAccessMethod":
+        kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, context))
 
         method = odxrequire(et_element.findtext("METHOD"))
 

odxtools/externaldoc.py

@@ -1,19 +1,19 @@
 from dataclasses import dataclass
-from typing import List, Optional
+from typing import Optional
 from xml.etree import ElementTree
 
 from .exceptions import odxrequire
-from .odxlink import OdxDocFragment
+from .odxdoccontext import OdxDocContext
 
 
-@dataclass
+@dataclass(kw_only=True)
 class ExternalDoc:
-    description: Optional[str]
+    description: str | None = None
     href: str
 
     @staticmethod
-    def from_et(et_element: Optional[ElementTree.Element],
-                doc_frags: List[OdxDocFragment]) -> Optional["ExternalDoc"]:
+    def from_et(et_element: ElementTree.Element | None,
+                context: OdxDocContext) -> Optional["ExternalDoc"]:
         if et_element is None:
             return None
 

odxtools/field.py

@@ -1,25 +1,25 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import List, Optional
 from xml.etree import ElementTree
 
 from .basicstructure import BasicStructure
 from .complexdop import ComplexDop
 from .environmentdatadescription import EnvironmentDataDescription
 from .exceptions import odxassert, odxrequire
-from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkRef, resolve_snref
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkRef, resolve_snref
 from .odxtypes import odxstr_to_bool
 from .snrefcontext import SnRefContext
 from .utils import dataclass_fields_asdict
 
 
-@dataclass
+@dataclass(kw_only=True)
 class Field(ComplexDop):
-    structure_ref: Optional[OdxLinkRef]
-    structure_snref: Optional[str]
-    env_data_desc_ref: Optional[OdxLinkRef]
-    env_data_desc_snref: Optional[str]
-    is_visible_raw: Optional[bool]
+    structure_ref: OdxLinkRef | None = None
+    structure_snref: str | None = None
+    env_data_desc_ref: OdxLinkRef | None = None
+    env_data_desc_snref: str | None = None
+    is_visible_raw: bool | None = None
 
     @property
     def structure(self) -> BasicStructure:
@@ -31,15 +31,15 @@ class Field(ComplexDop):
         return self.is_visible_raw in (None, True)
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "Field":
-        kwargs = dataclass_fields_asdict(ComplexDop.from_et(et_element, doc_frags))
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "Field":
+        kwargs = dataclass_fields_asdict(ComplexDop.from_et(et_element, context))
 
-        structure_ref = OdxLinkRef.from_et(et_element.find("BASIC-STRUCTURE-REF"), doc_frags)
+        structure_ref = OdxLinkRef.from_et(et_element.find("BASIC-STRUCTURE-REF"), context)
         structure_snref = None
         if (edsnr_elem := et_element.find("BASIC-STRUCTURE-SNREF")) is not None:
             structure_snref = edsnr_elem.get("SHORT-NAME")
 
-        env_data_desc_ref = OdxLinkRef.from_et(et_element.find("ENV-DATA-DESC-REF"), doc_frags)
+        env_data_desc_ref = OdxLinkRef.from_et(et_element.find("ENV-DATA-DESC-REF"), context)
         env_data_desc_snref = None
         if (edsnr_elem := et_element.find("ENV-DATA-DESC-SNREF")) is not None:
             env_data_desc_snref = edsnr_elem.get("SHORT-NAME")
@@ -54,8 +54,8 @@ class Field(ComplexDop):
             **kwargs)
 
     def __post_init__(self) -> None:
-        self._structure: Optional[BasicStructure] = None
-        self._env_data_desc: Optional[EnvironmentDataDescription] = None
+        self._structure: BasicStructure | None = None
+        self._env_data_desc: EnvironmentDataDescription | None = None
         num_struct_refs = 0 if self.structure_ref is None else 1
         num_struct_refs += 0 if self.structure_snref is None else 1
 
@@ -87,5 +87,5 @@ class Field(ComplexDop):
             self._env_data_desc = resolve_snref(self.env_data_desc_snref, ddds.env_data_descs,
                                                 EnvironmentDataDescription)
 
-    def get_static_bit_length(self) -> Optional[int]:
+    def get_static_bit_length(self) -> int | None:
         return None

odxtools/functionalclass.py

@@ -1,34 +1,34 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import Any, Dict, List, Optional
+from typing import Any
 from xml.etree import ElementTree
 
 from .admindata import AdminData
 from .element import IdentifiableElement
-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
 
 
-@dataclass
+@dataclass(kw_only=True)
 class FunctionalClass(IdentifiableElement):
     """
     Corresponds to FUNCT-CLASS.
     """
 
-    admin_data: Optional[AdminData]
+    admin_data: AdminData | None = None
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element,
-                doc_frags: List[OdxDocFragment]) -> "FunctionalClass":
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "FunctionalClass":
 
-        kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, doc_frags))
+        kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, context))
 
-        admin_data = AdminData.from_et(et_element.find("ADMIN-DATA"), doc_frags)
+        admin_data = AdminData.from_et(et_element.find("ADMIN-DATA"), context)
 
         return FunctionalClass(admin_data=admin_data, **kwargs)
 
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         return {self.odx_id: self}
 
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:

odxtools/inputparam.py

@@ -1,6 +1,6 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import Any, Dict, List, Optional
+from typing import Any
 from xml.etree import ElementTree
 
 from deprecation import deprecated
@@ -8,17 +8,18 @@ from deprecation import deprecated
 from .dopbase import DopBase
 from .element import NamedElement
 from .exceptions import odxrequire
-from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkId, OdxLinkRef
 from .snrefcontext import SnRefContext
 from .utils import dataclass_fields_asdict
 
 
-@dataclass
+@dataclass(kw_only=True)
 class InputParam(NamedElement):
-    physical_default_value: Optional[str]
+    physical_default_value: str | None = None
     dop_base_ref: OdxLinkRef
-    oid: Optional[str]
-    semantic: Optional[str]
+    oid: str | None = None
+    semantic: str | None = None
 
     @property
     def dop(self) -> DopBase:
@@ -30,11 +31,11 @@ class InputParam(NamedElement):
         return self._dop
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "InputParam":
-        kwargs = dataclass_fields_asdict(NamedElement.from_et(et_element, doc_frags))
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "InputParam":
+        kwargs = dataclass_fields_asdict(NamedElement.from_et(et_element, context))
 
         physical_default_value = et_element.findtext("PHYSICAL-DEFAULT-VALUE")
-        dop_base_ref = odxrequire(OdxLinkRef.from_et(et_element.find("DOP-BASE-REF"), doc_frags))
+        dop_base_ref = odxrequire(OdxLinkRef.from_et(et_element.find("DOP-BASE-REF"), context))
 
         oid = et_element.get("OID")
         semantic = et_element.get("SEMANTIC")
@@ -46,7 +47,7 @@ class InputParam(NamedElement):
             semantic=semantic,
             **kwargs)
 
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         return {}
 
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:

odxtools/internalconstr.py

@@ -1,38 +1,37 @@
 # SPDX-License-Identifier: MIT
-from dataclasses import dataclass
-from typing import List, Optional
+from dataclasses import dataclass, field
 from xml.etree import ElementTree
 
 from .compumethods.limit import Limit
-from .odxlink import OdxDocFragment
+from .odxdoccontext import OdxDocContext
 from .odxtypes import DataType
 from .scaleconstr import ScaleConstr
 
 
-@dataclass
+@dataclass(kw_only=True)
 class InternalConstr:
     """This class represents INTERNAL-CONSTR objects.
     """
 
     # TODO: Enforce the internal and physical constraints.
 
-    lower_limit: Optional[Limit]
-    upper_limit: Optional[Limit]
-    scale_constrs: List[ScaleConstr]
+    lower_limit: Limit | None = None
+    upper_limit: Limit | None = None
+    scale_constrs: list[ScaleConstr] = field(default_factory=list)
 
     value_type: DataType
 
     @staticmethod
-    def constr_from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment], *,
+    def constr_from_et(et_element: ElementTree.Element, context: OdxDocContext, *,
                        value_type: DataType) -> "InternalConstr":
 
         lower_limit = Limit.limit_from_et(
-            et_element.find("LOWER-LIMIT"), doc_frags, value_type=value_type)
+            et_element.find("LOWER-LIMIT"), context, value_type=value_type)
         upper_limit = Limit.limit_from_et(
-            et_element.find("UPPER-LIMIT"), doc_frags, value_type=value_type)
+            et_element.find("UPPER-LIMIT"), context, value_type=value_type)
 
         scale_constrs = [
-            ScaleConstr.scale_constr_from_et(sc_el, doc_frags, value_type=value_type)
+            ScaleConstr.scale_constr_from_et(sc_el, context, value_type=value_type)
             for sc_el in et_element.iterfind("SCALE-CONSTRS/SCALE-CONSTR")
         ]
 

odxtools/isotp_state_machine.py

@@ -4,9 +4,10 @@
 import asyncio
 import re
 import sys
+from collections.abc import AsyncGenerator, Iterable
 from enum import IntEnum
 from io import TextIOBase
-from typing import AsyncGenerator, Iterable, List, Optional, TextIO, Tuple, Union
+from typing import TextIO
 
 import bitstruct
 import can
@@ -32,7 +33,7 @@ class IsoTpStateMachine:
     can_fd_log_frame_re = re.compile(
         "\\([0-9.]*\\) *([a-zA-Z0-9_-]*) ([0-9A-Fa-f]+)##[0-9A-Fa-f]([0-9A-Fa-f]+)")
 
-    def __init__(self, can_rx_ids: Union[int, List[int]]):
+    def __init__(self, can_rx_ids: int | list[int]):
         if isinstance(can_rx_ids, int):
             can_rx_ids = [can_rx_ids]
 
@@ -40,10 +41,10 @@ class IsoTpStateMachine:
         assert isinstance(self._can_rx_ids, list)
 
         self._telegram_specified_len = [0] * len(can_rx_ids)
-        self._telegram_data: List[Optional[bytearray]] = [None] * len(can_rx_ids)
+        self._telegram_data: list[bytearray | None] = [None] * len(can_rx_ids)
         self._telegram_last_rx_fragment_idx = [0] * len(can_rx_ids)
 
-    def decode_rx_frame(self, rx_id: int, data: bytes) -> Iterable[Tuple[int, bytes]]:
+    def decode_rx_frame(self, rx_id: int, data: bytes) -> Iterable[tuple[int, bytes]]:
         """Handle the ISO-TP state transitions caused by a CAN frame.
 
         E.g., add some data to a telegram, etc. Returns a generator of
@@ -114,8 +115,8 @@ class IsoTpStateMachine:
         else:
             self.on_frame_type_error(telegram_idx, frame_type)
 
-    async def read_telegrams(self, bus: Union[can.BusABC,
-                                              TextIO]) -> AsyncGenerator[Tuple[int, bytes], None]:
+    async def read_telegrams(self,
+                             bus: can.BusABC | TextIO) -> AsyncGenerator[tuple[int, bytes], None]:
         """This is equivalent to the :py:meth:`file.readlines()` method, but
         it yields ISO-TP telegrams instead of lines.
 
@@ -184,7 +185,7 @@ class IsoTpStateMachine:
         """
         return self._can_rx_ids[telegram_idx]
 
-    def telegram_data(self, telegram_idx: int) -> Optional[bytes]:
+    def telegram_data(self, telegram_idx: int) -> bytes | None:
         """Given a Telegram index, returns the data received for this telegram
         so far.
 
@@ -233,8 +234,8 @@ class IsoTpActiveDecoder(IsoTpStateMachine):
 
     def __init__(self,
                  can_bus: can.BusABC,
-                 can_rx_ids: List[int],
-                 can_tx_ids: List[int],
+                 can_rx_ids: list[int],
+                 can_tx_ids: list[int],
                  padding_size: int = 0,
                  padding_value: int = 0xAA):
         self._can_bus = can_bus
@@ -251,8 +252,8 @@ class IsoTpActiveDecoder(IsoTpStateMachine):
         assert len(self._can_rx_ids) == len(self._can_tx_ids)
         assert set(self._can_rx_ids).isdisjoint(set(self._can_tx_ids))  # correct?
 
-        self._block_size: List[Optional[int]] = [None] * len(self._can_rx_ids)
-        self._frames_received: List[Optional[int]] = [None] * len(self._can_rx_ids)
+        self._block_size: list[int | None] = [None] * len(self._can_rx_ids)
+        self._frames_received: list[int | None] = [None] * len(self._can_rx_ids)
 
     def can_tx_id(self, telegram_idx: int) -> int:
         """Given a Telegram index, returns the CAN ID for sending data.

odxtools/leadinglengthinfotype.py

@@ -1,6 +1,5 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import List
 from xml.etree import ElementTree
 
 from typing_extensions import override
@@ -9,12 +8,12 @@ from .decodestate import DecodeState
 from .diagcodedtype import DctType, DiagCodedType
 from .encodestate import EncodeState
 from .exceptions import EncodeError, odxassert, odxraise, odxrequire
-from .odxlink import OdxDocFragment
+from .odxdoccontext import OdxDocContext
 from .odxtypes import AtomicOdxType, DataType
 from .utils import dataclass_fields_asdict
 
 
-@dataclass
+@dataclass(kw_only=True)
 class LeadingLengthInfoType(DiagCodedType):
     #: bit length of the length specifier field
     #:
@@ -29,9 +28,8 @@ class LeadingLengthInfoType(DiagCodedType):
 
     @staticmethod
     @override
-    def from_et(et_element: ElementTree.Element,
-                doc_frags: List[OdxDocFragment]) -> "LeadingLengthInfoType":
-        kwargs = dataclass_fields_asdict(DiagCodedType.from_et(et_element, doc_frags))
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "LeadingLengthInfoType":
+        kwargs = dataclass_fields_asdict(DiagCodedType.from_et(et_element, context))
 
         bit_length = int(odxrequire(et_element.findtext("BIT-LENGTH")))
 

odxtools/library.py

@@ -1,16 +1,17 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import Any, Dict, List, Optional, cast
+from typing import Any, cast
 from xml.etree import ElementTree
 
 from .element import IdentifiableElement
 from .exceptions import odxraise, odxrequire
-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
 
 
-@dataclass
+@dataclass(kw_only=True)
 class Library(IdentifiableElement):
     """
     A library defines a shared library used for single ECU jobs etc.
@@ -19,19 +20,19 @@ class Library(IdentifiableElement):
     """
 
     code_file: str
-    encryption: Optional[str]
+    encryption: str | None = None
     syntax: str
     revision: str
-    entrypoint: Optional[str]
+    entrypoint: str | None = None
 
     @property
     def code(self) -> bytes:
         return self._code
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "Library":
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "Library":
 
-        kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, doc_frags))
+        kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, context))
 
         code_file = odxrequire(et_element.findtext("CODE-FILE"))
         encryption = et_element.findtext("ENCRYPTION")
@@ -47,7 +48,7 @@ class Library(IdentifiableElement):
             entrypoint=entrypoint,
             **kwargs)
 
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         return {self.odx_id: self}
 
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:

odxtools/linkeddtcdop.py

@@ -1,21 +1,22 @@
 # SPDX-License-Identifier: MIT
-from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Dict, List
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, Any
 from xml.etree import ElementTree
 
 from .diagnostictroublecode import DiagnosticTroubleCode
 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 .snrefcontext import SnRefContext
 
 if TYPE_CHECKING:
     from .dtcdop import DtcDop
 
 
-@dataclass
+@dataclass(kw_only=True)
 class LinkedDtcDop:
-    not_inherited_dtc_snrefs: List[str]
+    not_inherited_dtc_snrefs: list[str] = field(default_factory=list)
     dtc_dop_ref: OdxLinkRef
 
     @property
@@ -31,19 +32,19 @@ class LinkedDtcDop:
         return self._dtc_dop.short_name
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "LinkedDtcDop":
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "LinkedDtcDop":
         not_inherited_dtc_snrefs = [
             odxrequire(el.get("SHORT-NAME"))
             for el in et_element.iterfind("NOT-INHERITED-DTC-SNREFS/"
                                           "NOT-INHERITED-DTC-SNREF")
         ]
 
-        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))
 
         return LinkedDtcDop(
             not_inherited_dtc_snrefs=not_inherited_dtc_snrefs, dtc_dop_ref=dtc_dop_ref)
 
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         return {}
 
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None: