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

odxtools/cli/decode.py

@@ -1,7 +1,6 @@
 # SPDX-License-Identifier: MIT
 import argparse
 import re
-from typing import Dict, List, Optional
 
 from ..database import Database
 from ..diagservice import DiagService
@@ -26,13 +25,13 @@ def get_display_value(v: ParameterValue) -> str:
 
 def print_summary(
     odxdb: Database,
-    ecu_variants: Optional[List[str]] = None,
+    ecu_variants: list[str] | None = None,
     data: bytes = b'',
     decode: bool = False,
 ) -> None:
     ecu_names = ecu_variants if ecu_variants else [ecu.short_name for ecu in odxdb.ecus]
-    service_db: Dict[str, DiagService] = {}
-    service_ecus: Dict[str, List[str]] = {}
+    service_db: dict[str, DiagService] = {}
+    service_ecus: dict[str, list[str]] = {}
     for ecu_name in ecu_names:
         ecu = odxdb.ecus[ecu_name]
         if not ecu:

odxtools/cli/find.py

@@ -1,6 +1,5 @@
 # SPDX-License-Identifier: MIT
 import argparse
-from typing import Dict, List, Optional
 
 from ..database import Database
 from ..diagservice import DiagService
@@ -24,13 +23,13 @@ def get_display_value(v: ParameterValue) -> str:
 
 
 def print_summary(odxdb: Database,
-                  service_names: List[str],
-                  ecu_variants: Optional[List[str]] = None,
+                  service_names: list[str],
+                  ecu_variants: list[str] | None = None,
                   allow_unknown_bit_lengths: bool = False,
                   print_params: bool = False) -> None:
     ecu_names = ecu_variants if ecu_variants else [ecu.short_name for ecu in odxdb.ecus]
-    service_db: Dict[str, DiagService] = {}
-    service_ecus: Dict[str, List[str]] = {}
+    service_db: dict[str, DiagService] = {}
+    service_ecus: dict[str, list[str]] = {}
     for ecu_name in ecu_names:
         ecu = odxdb.ecus[ecu_name]
         if not ecu:

odxtools/cli/list.py

@@ -1,6 +1,6 @@
 # SPDX-License-Identifier: MIT
 import argparse
-from typing import Callable, List, Optional
+from collections.abc import Callable
 
 import rich
 
@@ -32,11 +32,11 @@ def print_summary(odxdb: Database,
                   print_state_transitions: bool = False,
                   print_audiences: bool = False,
                   allow_unknown_bit_lengths: bool = False,
-                  variants: Optional[List[str]] = None,
+                  variants: list[str] | None = None,
                   service_filter: Callable[[DiagComm], bool] = lambda x: True) -> None:
 
     diag_layer_names = [dl.short_name for dl in odxdb.diag_layers]
-    diag_layers: List[DiagLayer] = []
+    diag_layers: list[DiagLayer] = []
 
     if variants is None:
         variants = diag_layer_names
@@ -59,7 +59,7 @@ def print_summary(odxdb: Database,
         rich.print(f"Diagnostic layer: '{dl.short_name}'")
         rich.print(f" Variant Type: {dl.variant_type.value}")
 
-        all_services: List[DiagComm] = sorted(dl.services, key=lambda x: x.short_name)
+        all_services: list[DiagComm] = sorted(dl.services, key=lambda x: x.short_name)
 
         if isinstance(dl, (BaseVariant, EcuVariant)):
             for proto in dl.protocols:
@@ -99,7 +99,7 @@ def print_summary(odxdb: Database,
                     else:
                         rich.print(f" Unidentifiable service: {service}")
         ddd_spec = dl.diag_data_dictionary_spec
-        data_object_properties: List[
+        data_object_properties: list[
             DataObjectProperty] = [] if ddd_spec is None else ddd_spec.data_object_props
         if print_dops and len(data_object_properties) > 0:
             rich.print("\n")
@@ -108,7 +108,7 @@ def print_summary(odxdb: Database,
                     data_object_properties, key=lambda x: (type(x).__name__, x.short_name)):
                 rich.print("  " + str(dop.short_name).replace("\n", "\n  "))
 
-        comparam_refs: List[ComparamInstance] = []
+        comparam_refs: list[ComparamInstance] = []
         if isinstance(dl, HierarchyElement):
             comparam_refs = dl.comparam_refs
 

odxtools/cli/main.py

@@ -1,7 +1,7 @@
 # SPDX-License-Identifier: MIT
 import argparse
 import importlib
-from typing import Any, List
+from typing import Any
 
 import odxtools
 import odxtools.exceptions
@@ -11,7 +11,7 @@ from .dummy_sub_parser import DummyTool
 
 # import the tool modules which can be loaded. if a tool
 # can't be loaded, add a dummy one
-tool_modules: List[Any] = []
+tool_modules: list[Any] = []
 for tool_name in ["list", "browse", "snoop", "find", "decode", "compare"]:
     try:
         tool_modules.append(importlib.import_module(f".{tool_name}", package="odxtools.cli"))

odxtools/cli/snoop.py

@@ -4,7 +4,7 @@
 import argparse
 import asyncio
 import sys
-from typing import Any, List, Optional, Type
+from typing import Any
 
 import can
 
@@ -103,7 +103,7 @@ def handle_telegram(telegram_id: int, payload: bytes) -> None:
               f"({payload!r}, {len(payload)} bytes)")
 
 
-def init_verbose_state_machine(BaseClass: Type[IsoTpStateMachine], *args: Any,
+def init_verbose_state_machine(BaseClass: type[IsoTpStateMachine], *args: Any,
                                **kwargs: Any) -> IsoTpStateMachine:
 
     class InformativeIsoTpDecoder(BaseClass):  # type: ignore[valid-type, misc]
@@ -246,7 +246,7 @@ def run(args: argparse.Namespace) -> None:
 
     protocol_name = args.protocol
     if odx_diag_layer is not None and protocol_name is not None:
-        protocols: Optional[List[Protocol]] = getattr(odx_diag_layer, "protocols", None)
+        protocols: list[Protocol] | None = getattr(odx_diag_layer, "protocols", None)
 
         if protocols is None:
             print(f"ECU variant {odx_diag_layer.short_name} is of type "

odxtools/codec.py

@@ -1,6 +1,6 @@
 # SPDX-License-Identifier: MIT
 import typing
-from typing import Optional, runtime_checkable
+from typing import runtime_checkable
 
 from .decodestate import DecodeState
 from .encodestate import EncodeState
@@ -17,12 +17,12 @@ class Codec(typing.Protocol):
     def short_name(self) -> str:
         return ""
 
-    def encode_into_pdu(self, physical_value: Optional[ParameterValue],
+    def encode_into_pdu(self, physical_value: ParameterValue | None,
                         encode_state: EncodeState) -> None:
         ...
 
     def decode_from_pdu(self, decode_state: DecodeState) -> ParameterValue:
         ...
 
-    def get_static_bit_length(self) -> Optional[int]:
+    def get_static_bit_length(self) -> int | None:
         ...

odxtools/commrelation.py

@@ -1,7 +1,7 @@
 # SPDX-License-Identifier: MIT
 import warnings
 from dataclasses import dataclass
-from typing import Any, Dict, List, Optional
+from typing import Any
 from xml.etree import ElementTree
 
 from .commrelationvaluetype import CommRelationValueType
@@ -9,33 +9,34 @@ from .description import Description
 from .diagcomm import DiagComm
 from .diagservice import DiagService
 from .exceptions import OdxWarning, odxraise, odxrequire
-from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef, resolve_snref
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkId, OdxLinkRef, resolve_snref
 from .parameters.parameter import Parameter
 from .snrefcontext import SnRefContext
 
 
-@dataclass
+@dataclass(kw_only=True)
 class CommRelation:
-    description: Optional[Description]
+    description: Description | None = None
     relation_type: str
-    diag_comm_ref: Optional[OdxLinkRef]
-    diag_comm_snref: Optional[str]
-    in_param_if_snref: Optional[str]
-    #in_param_if_snpathref: Optional[str] # TODO
-    out_param_if_snref: Optional[str]
-    #out_param_if_snpathref: Optional[str] # TODO
-    value_type_raw: Optional[CommRelationValueType]
+    diag_comm_ref: OdxLinkRef | None = None
+    diag_comm_snref: str | None = None
+    in_param_if_snref: str | None = None
+    #in_param_if_snpathref: Optional[str] = None # TODO
+    out_param_if_snref: str | None = None
+    #out_param_if_snpathref: Optional[str] = None # TODO
+    value_type_raw: CommRelationValueType | None = None
 
     @property
     def diag_comm(self) -> DiagComm:
         return self._diag_comm
 
     @property
-    def in_param_if(self) -> Optional[Parameter]:
+    def in_param_if(self) -> Parameter | None:
         return self._in_param_if
 
     @property
-    def out_param_if(self) -> Optional[Parameter]:
+    def out_param_if(self) -> Parameter | None:
         return self._out_param_if
 
     @property
@@ -46,11 +47,11 @@ class CommRelation:
         return self.value_type_raw
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "CommRelation":
-        description = Description.from_et(et_element.find("DESC"), doc_frags)
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "CommRelation":
+        description = Description.from_et(et_element.find("DESC"), context)
         relation_type = odxrequire(et_element.findtext("RELATION-TYPE"))
 
-        diag_comm_ref = OdxLinkRef.from_et(et_element.find("DIAG-COMM-REF"), doc_frags)
+        diag_comm_ref = OdxLinkRef.from_et(et_element.find("DIAG-COMM-REF"), context)
         diag_comm_snref = None
         if (diag_comm_snref_elem := et_element.find("DIAG-COMM-SNREF")) is not None:
             diag_comm_snref = odxrequire(diag_comm_snref_elem.get("SHORT-NAME"))
@@ -85,7 +86,7 @@ class CommRelation:
             out_param_if_snref=out_param_if_snref,
             value_type_raw=value_type_raw)
 
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         return {}
 
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:

odxtools/companydata.py

@@ -1,40 +1,40 @@
 # 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 .companyspecificinfo import CompanySpecificInfo
 from .element import IdentifiableElement
 from .exceptions import odxrequire
 from .nameditemlist import NamedItemList
-from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkId
 from .snrefcontext import SnRefContext
 from .teammember import TeamMember
 from .utils import dataclass_fields_asdict
 
 
-@dataclass
+@dataclass(kw_only=True)
 class CompanyData(IdentifiableElement):
-    roles: List[str]
-    team_members: NamedItemList[TeamMember]
-    company_specific_info: Optional[CompanySpecificInfo]
+    roles: list[str] = field(default_factory=list)
+    team_members: NamedItemList[TeamMember] = field(default_factory=NamedItemList)
+    company_specific_info: CompanySpecificInfo | None = None
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "CompanyData":
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "CompanyData":
 
-        kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, doc_frags))
+        kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, context))
 
         roles = []
         if (roles_elem := et_element.find("ROLES")) is not None:
             roles = [odxrequire(role.text) for role in roles_elem.iterfind("ROLE")]
         team_members = [
-            TeamMember.from_et(tm, doc_frags)
+            TeamMember.from_et(tm, context)
             for tm in et_element.iterfind("TEAM-MEMBERS/TEAM-MEMBER")
         ]
         company_specific_info = None
         if (company_specific_info_elem := et_element.find("COMPANY-SPECIFIC-INFO")) is not None:
-            company_specific_info = CompanySpecificInfo.from_et(company_specific_info_elem,
-                                                                doc_frags)
+            company_specific_info = CompanySpecificInfo.from_et(company_specific_info_elem, context)
 
         return CompanyData(
             roles=roles,
@@ -43,7 +43,7 @@ class CompanyData(IdentifiableElement):
             **kwargs,
         )
 
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         result = {self.odx_id: self}
 
         for tm in self.team_members:

odxtools/companydocinfo.py

@@ -1,42 +1,40 @@
 # 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 .companydata import CompanyData
 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 .specialdatagroup import SpecialDataGroup
 from .teammember import TeamMember
 
 
-@dataclass
+@dataclass(kw_only=True)
 class CompanyDocInfo:
     company_data_ref: OdxLinkRef
-    team_member_ref: Optional[OdxLinkRef]
-    doc_label: Optional[str]
-    sdgs: List[SpecialDataGroup]
+    team_member_ref: OdxLinkRef | None = None
+    doc_label: str | None = None
+    sdgs: list[SpecialDataGroup] = field(default_factory=list)
 
     @property
     def company_data(self) -> CompanyData:
         return self._company_data
 
     @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]) -> "CompanyDocInfo":
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "CompanyDocInfo":
         # the company data reference is mandatory
         company_data_ref = odxrequire(
-            OdxLinkRef.from_et(et_element.find("COMPANY-DATA-REF"), doc_frags))
-        team_member_ref = OdxLinkRef.from_et(et_element.find("TEAM-MEMBER-REF"), doc_frags)
+            OdxLinkRef.from_et(et_element.find("COMPANY-DATA-REF"), context))
+        team_member_ref = OdxLinkRef.from_et(et_element.find("TEAM-MEMBER-REF"), context)
         doc_label = et_element.findtext("DOC-LABEL")
-        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 CompanyDocInfo(
             company_data_ref=company_data_ref,
@@ -45,7 +43,7 @@ class CompanyDocInfo:
             sdgs=sdgs,
         )
 
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         result = {}
 
         for sdg in self.sdgs:
@@ -56,7 +54,7 @@ class CompanyDocInfo:
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
         self._company_data = odxlinks.resolve(self.company_data_ref, CompanyData)
 
-        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/companyrevisioninfo.py

@@ -1,37 +1,37 @@
 # 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 .companydata import CompanyData
 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
 
 
-@dataclass
+@dataclass(kw_only=True)
 class CompanyRevisionInfo:
     company_data_ref: OdxLinkRef
-    revision_label: Optional[str]
-    state: Optional[str]
+    revision_label: str | None = None
+    state: str | None = None
 
     @property
     def company_data(self) -> CompanyData:
         return self._company_data
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element,
-                doc_frags: List[OdxDocFragment]) -> "CompanyRevisionInfo":
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "CompanyRevisionInfo":
 
         company_data_ref = odxrequire(
-            OdxLinkRef.from_et(et_element.find("COMPANY-DATA-REF"), doc_frags))
+            OdxLinkRef.from_et(et_element.find("COMPANY-DATA-REF"), context))
         revision_label = et_element.findtext("REVISION-LABEL")
         state = et_element.findtext("STATE")
 
         return CompanyRevisionInfo(
             company_data_ref=company_data_ref, revision_label=revision_label, state=state)
 
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         return {}
 
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:

odxtools/companyspecificinfo.py

@@ -1,34 +1,32 @@
 # SPDX-License-Identifier: MIT
-from dataclasses import dataclass
-from typing import Any, Dict, List
+from dataclasses import dataclass, field
+from typing import Any
 from xml.etree import ElementTree
 
-from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkId
 from .relateddoc import RelatedDoc
 from .snrefcontext import SnRefContext
 from .specialdatagroup import SpecialDataGroup
 
 
-@dataclass
+@dataclass(kw_only=True)
 class CompanySpecificInfo:
-    related_docs: List[RelatedDoc]
-    sdgs: List[SpecialDataGroup]
+    related_docs: list[RelatedDoc] = field(default_factory=list)
+    sdgs: list[SpecialDataGroup] = field(default_factory=list)
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element,
-                doc_frags: List[OdxDocFragment]) -> "CompanySpecificInfo":
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "CompanySpecificInfo":
         related_docs = [
-            RelatedDoc.from_et(rd, doc_frags)
+            RelatedDoc.from_et(rd, context)
             for rd in et_element.iterfind("RELATED-DOCS/RELATED-DOC")
         ]
 
-        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 CompanySpecificInfo(related_docs=related_docs, sdgs=sdgs)
 
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         result = {}
 
         for rd in self.related_docs:

odxtools/comparam.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 .basecomparam import BaseComparam
 from .dataobjectproperty import DataObjectProperty
 from .exceptions import odxrequire
-from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkId, OdxLinkRef
 from .odxtypes import AtomicOdxType
 from .snrefcontext import SnRefContext
 from .utils import dataclass_fields_asdict
 
 
-@dataclass
+@dataclass(kw_only=True)
 class Comparam(BaseComparam):
     physical_default_value_raw: str
     dop_ref: OdxLinkRef
@@ -27,16 +28,16 @@ class Comparam(BaseComparam):
         return self._dop
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "Comparam":
-        kwargs = dataclass_fields_asdict(BaseComparam.from_et(et_element, doc_frags))
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "Comparam":
+        kwargs = dataclass_fields_asdict(BaseComparam.from_et(et_element, context))
 
         physical_default_value_raw = odxrequire(et_element.findtext("PHYSICAL-DEFAULT-VALUE"))
-        dop_ref = odxrequire(OdxLinkRef.from_et(et_element.find("DATA-OBJECT-PROP-REF"), doc_frags))
+        dop_ref = odxrequire(OdxLinkRef.from_et(et_element.find("DATA-OBJECT-PROP-REF"), context))
 
         return Comparam(
             dop_ref=dop_ref, physical_default_value_raw=physical_default_value_raw, **kwargs)
 
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         return super()._build_odxlinks()
 
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:

odxtools/comparaminstance.py

@@ -1,7 +1,7 @@
 # SPDX-License-Identifier: MIT
 import warnings
 from dataclasses import dataclass
-from typing import Any, Dict, List, Optional, Union
+from typing import Any
 from xml.etree import ElementTree
 
 from .basecomparam import BaseComparam
@@ -9,21 +9,22 @@ from .comparam import Comparam
 from .complexcomparam import ComplexComparam, ComplexValue, create_complex_value_from_et
 from .description import Description
 from .exceptions import OdxWarning, odxraise, odxrequire
-from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkId, OdxLinkRef
 from .snrefcontext import SnRefContext
 
 
-@dataclass
+@dataclass(kw_only=True)
 class ComparamInstance:
     """
     This class represents a communication parameter.
 
     Be aware that the ODX specification calls this class COMPARAM-REF!
     """
-    value: Union[str, ComplexValue]
-    description: Optional[Description]
-    protocol_snref: Optional[str]
-    prot_stack_snref: Optional[str]
+    value: str | ComplexValue
+    description: Description | None = None
+    protocol_snref: str | None = None
+    prot_stack_snref: str | None = None
     spec_ref: OdxLinkRef
 
     @property
@@ -35,14 +36,13 @@ class ComparamInstance:
         return self.spec.short_name
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element,
-                doc_frags: List[OdxDocFragment]) -> "ComparamInstance":
-        spec_ref = odxrequire(OdxLinkRef.from_et(et_element, doc_frags))
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "ComparamInstance":
+        spec_ref = odxrequire(OdxLinkRef.from_et(et_element, context))
 
         # ODX standard v2.0.0 defined only VALUE. ODX v2.0.1 decided
         # to break things and change it to a choice between SIMPLE-VALUE
         # and COMPLEX-VALUE
-        value: Union[str, List[Union[str, ComplexValue]]]
+        value: str | list[str | ComplexValue]
         if et_element.find("VALUE") is not None:
             value = odxrequire(et_element.findtext("VALUE"))
         elif et_element.find("SIMPLE-VALUE") is not None:
@@ -50,7 +50,7 @@ class ComparamInstance:
         else:
             value = create_complex_value_from_et(odxrequire(et_element.find("COMPLEX-VALUE")))
 
-        description = Description.from_et(et_element.find("DESC"), doc_frags)
+        description = Description.from_et(et_element.find("DESC"), context)
 
         protocol_snref = None
         if (psnref_elem := et_element.find("PROTOCOL-SNREF")) is not None:
@@ -68,7 +68,7 @@ class ComparamInstance:
             prot_stack_snref=prot_stack_snref,
         )
 
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         return {}
 
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
@@ -98,7 +98,7 @@ class ComparamInstance:
 
         return result
 
-    def get_subvalue(self, subparam_name: str) -> Optional[str]:
+    def get_subvalue(self, subparam_name: str) -> str | None:
         """Retrieve the value of a complex communication parameter's sub-parameter by name
 
         This takes the default value of the comparam (if any) into

odxtools/comparamspec.py

@@ -1,11 +1,12 @@
 # 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 .nameditemlist import NamedItemList
 from .odxcategory import OdxCategory
-from .odxlink import DocType, OdxDocFragment, OdxLinkDatabase, OdxLinkId
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkId
 from .protstack import ProtStack
 from .snrefcontext import SnRefContext
 from .utils import dataclass_fields_asdict
@@ -14,27 +15,25 @@ if TYPE_CHECKING:
     from .database import Database
 
 
-@dataclass
+@dataclass(kw_only=True)
 class ComparamSpec(OdxCategory):
 
-    prot_stacks: NamedItemList[ProtStack]
+    prot_stacks: NamedItemList[ProtStack] = field(default_factory=NamedItemList)
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "ComparamSpec":
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "ComparamSpec":
 
-        base_obj = OdxCategory.category_from_et(
-            et_element, doc_frags, doc_type=DocType.COMPARAM_SPEC)
-        doc_frags = base_obj.odx_id.doc_fragments
+        base_obj = OdxCategory.from_et(et_element, context)
         kwargs = dataclass_fields_asdict(base_obj)
 
         prot_stacks = NamedItemList([
-            ProtStack.from_et(dl_element, doc_frags)
+            ProtStack.from_et(dl_element, context)
             for dl_element in et_element.iterfind("PROT-STACKS/PROT-STACK")
         ])
 
         return ComparamSpec(prot_stacks=prot_stacks, **kwargs)
 
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         odxlinks = super()._build_odxlinks()
 
         for ps in self.prot_stacks: