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

odxtools/additionalaudience.py

@@ -4,21 +4,21 @@ from typing import Any
 from xml.etree import ElementTree
 
 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 AdditionalAudience(IdentifiableElement):
     """
     Corresponds to ADDITIONAL-AUDIENCE.
     """
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element,
-                doc_frags: list[OdxDocFragment]) -> "AdditionalAudience":
-        kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, doc_frags))
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "AdditionalAudience":
+        kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, context))
 
         return AdditionalAudience(**kwargs)
 

odxtools/admindata.py

@@ -1,23 +1,24 @@
 # SPDX-License-Identifier: MIT
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from typing import Any, Optional
 from xml.etree import ElementTree
 
 from .companydocinfo import CompanyDocInfo
 from .docrevision import DocRevision
-from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkId
 from .snrefcontext import SnRefContext
 
 
-@dataclass
+@dataclass(kw_only=True)
 class AdminData:
-    language: str | None
-    company_doc_infos: list[CompanyDocInfo]
-    doc_revisions: list[DocRevision]
+    language: str | None = None
+    company_doc_infos: list[CompanyDocInfo] = field(default_factory=list)
+    doc_revisions: list[DocRevision] = field(default_factory=list)
 
     @staticmethod
     def from_et(et_element: ElementTree.Element | None,
-                doc_frags: list[OdxDocFragment]) -> Optional["AdminData"]:
+                context: OdxDocContext) -> Optional["AdminData"]:
 
         if et_element is None:
             return None
@@ -25,12 +26,12 @@ class AdminData:
         language = et_element.findtext("LANGUAGE")
 
         company_doc_infos = [
-            CompanyDocInfo.from_et(cdi_elem, doc_frags)
+            CompanyDocInfo.from_et(cdi_elem, context)
             for cdi_elem in et_element.iterfind("COMPANY-DOC-INFOS/COMPANY-DOC-INFO")
         ]
 
         doc_revisions = [
-            DocRevision.from_et(dr_elem, doc_frags)
+            DocRevision.from_et(dr_elem, context)
             for dr_elem in et_element.iterfind("DOC-REVISIONS/DOC-REVISION")
         ]
 

odxtools/audience.py

@@ -1,25 +1,26 @@
 # SPDX-License-Identifier: MIT
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from typing import Any
 from xml.etree import ElementTree
 
 from .additionalaudience import AdditionalAudience
 from .nameditemlist import NamedItemList
-from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkId, OdxLinkRef
 from .odxtypes import odxstr_to_bool
 from .snrefcontext import SnRefContext
 
 
-@dataclass
+@dataclass(kw_only=True)
 class Audience:
-    enabled_audience_refs: list[OdxLinkRef]
-    disabled_audience_refs: list[OdxLinkRef]
+    enabled_audience_refs: list[OdxLinkRef] = field(default_factory=list)
+    disabled_audience_refs: list[OdxLinkRef] = field(default_factory=list)
 
-    is_supplier_raw: bool | None
-    is_development_raw: bool | None
-    is_manufacturing_raw: bool | None
-    is_aftersales_raw: bool | None
-    is_aftermarket_raw: bool | None
+    is_supplier_raw: bool | None = None
+    is_development_raw: bool | None = None
+    is_manufacturing_raw: bool | None = None
+    is_aftersales_raw: bool | None = None
+    is_aftermarket_raw: bool | None = None
 
     @property
     def is_supplier(self) -> bool:
@@ -50,15 +51,14 @@ class Audience:
         return self._disabled_audiences
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element, doc_frags: list[OdxDocFragment]) -> "Audience":
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "Audience":
 
         enabled_audience_refs = [
-            OdxLinkRef.from_et(ref, doc_frags)
-            for ref in et_element.iterfind("ENABLED-AUDIENCE-REFS/"
-                                           "ENABLED-AUDIENCE-REF")
+            OdxLinkRef.from_et(ref, context) for ref in et_element.iterfind("ENABLED-AUDIENCE-REFS/"
+                                                                            "ENABLED-AUDIENCE-REF")
         ]
         disabled_audience_refs = [
-            OdxLinkRef.from_et(ref, doc_frags)
+            OdxLinkRef.from_et(ref, context)
             for ref in et_element.iterfind("DISABLED-AUDIENCE-REFS/"
                                            "DISABLED-AUDIENCE-REF")
         ]

odxtools/basecomparam.py

@@ -5,23 +5,24 @@ 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 .standardizationlevel import StandardizationLevel
 from .usage import Usage
 from .utils import dataclass_fields_asdict
 
 
-@dataclass
+@dataclass(kw_only=True)
 class BaseComparam(IdentifiableElement):
     param_class: str
     cptype: StandardizationLevel
-    display_level: int | None
-    cpusage: Usage | None  # Required in ODX 2.2, missing in ODX 2.0
+    display_level: int | None = None
+    cpusage: Usage | None = None  # Required in ODX 2.2, missing in ODX 2.0
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element, doc_frags: list[OdxDocFragment]) -> "BaseComparam":
-        kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, doc_frags))
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "BaseComparam":
+        kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, context))
 
         param_class = odxrequire(et_element.attrib.get("PARAM-CLASS"))
 

odxtools/basevariantpattern.py

@@ -1,5 +1,5 @@
 # SPDX-License-Identifier: MIT
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from xml.etree import ElementTree
 
 from typing_extensions import override
@@ -7,23 +7,23 @@ from typing_extensions import override
 from .exceptions import odxassert
 from .matchingbasevariantparameter import MatchingBaseVariantParameter
 from .matchingparameter import MatchingParameter
-from .odxlink import OdxDocFragment
+from .odxdoccontext import OdxDocContext
 from .variantpattern import VariantPattern
 
 
-@dataclass
+@dataclass(kw_only=True)
 class BaseVariantPattern(VariantPattern):
     """Base variant patterns are variant patterns used to identify the
     base variant of an ECU.
     """
-    matching_base_variant_parameters: list[MatchingBaseVariantParameter]
+    matching_base_variant_parameters: list[MatchingBaseVariantParameter] = field(
+        default_factory=list)
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element,
-                doc_frags: list[OdxDocFragment]) -> "BaseVariantPattern":
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "BaseVariantPattern":
 
         matching_base_variant_parameters = [
-            MatchingBaseVariantParameter.from_et(mbvp_el, doc_frags)
+            MatchingBaseVariantParameter.from_et(mbvp_el, context)
             for mbvp_el in et_element.iterfind("MATCHING-BASE-VARIANT-PARAMETERS/"
                                                "MATCHING-BASE-VARIANT-PARAMETER")
         ]

odxtools/basicstructure.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
 
@@ -14,7 +14,8 @@ from .decodestate import DecodeState
 from .encodestate import EncodeState
 from .exceptions import DecodeError, odxraise
 from .nameditemlist import NamedItemList
-from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkId
 from .odxtypes import ParameterValue
 from .parameters.createanyparameter import create_any_parameter_from_et
 from .parameters.parameter import Parameter
@@ -22,7 +23,7 @@ from .snrefcontext import SnRefContext
 from .utils import dataclass_fields_asdict
 
 
-@dataclass
+@dataclass(kw_only=True)
 class BasicStructure(ComplexDop):
     """Base class for structure-like objects
 
@@ -30,8 +31,8 @@ class BasicStructure(ComplexDop):
     data objects. All structure-like objects adhere to the
     `CompositeCodec` type protocol.
     """
-    byte_size: int | None
-    parameters: NamedItemList[Parameter]
+    byte_size: int | None = None
+    parameters: NamedItemList[Parameter] = field(default_factory=NamedItemList)
 
     @property
     def required_parameters(self) -> list[Parameter]:
@@ -42,15 +43,14 @@ class BasicStructure(ComplexDop):
         return composite_codec_get_free_parameters(self)
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element,
-                doc_frags: list[OdxDocFragment]) -> "BasicStructure":
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "BasicStructure":
         """Read a BASIC-STRUCTURE."""
-        kwargs = dataclass_fields_asdict(ComplexDop.from_et(et_element, doc_frags))
+        kwargs = dataclass_fields_asdict(ComplexDop.from_et(et_element, context))
 
         byte_size_str = et_element.findtext("BYTE-SIZE")
         byte_size = int(byte_size_str) if byte_size_str is not None else None
         parameters = NamedItemList([
-            create_any_parameter_from_et(et_parameter, doc_frags)
+            create_any_parameter_from_et(et_parameter, context)
             for et_parameter in et_element.iterfind("PARAMS/PARAM")
         ])
 

odxtools/cli/_print_utils.py

@@ -214,7 +214,7 @@ def extract_parameter_tabulation_data(parameters: list[Parameter]) -> RichTable:
             value_column.append(str(param.coded_values))
             value_type_column.append('coded values')
             dop_column.append("")
-        elif isinstance(param, PhysicalConstantParameter | SystemParameter | ValueParameter):
+        elif isinstance(param, (PhysicalConstantParameter, SystemParameter, ValueParameter)):
             # this is a hack to make this routine work for parameters
             # which reference DOPs of a type that a is not yet
             # internalized. (all parameter objects of the tested types

odxtools/cli/browse.py

@@ -370,7 +370,7 @@ def browse(odxdb: Database) -> None:
 
             codec = answer.get("message_type")
             if codec is not None:
-                assert isinstance(codec, Request | Response)
+                assert isinstance(codec, (Request, Response))
                 table = extract_parameter_tabulation_data(codec.parameters)
                 print(table)
 

odxtools/cli/list.py

@@ -61,7 +61,7 @@ def print_summary(odxdb: Database,
 
         all_services: list[DiagComm] = sorted(dl.services, key=lambda x: x.short_name)
 
-        if isinstance(dl, BaseVariant | EcuVariant):
+        if isinstance(dl, (BaseVariant, EcuVariant)):
             for proto in dl.protocols:
                 if (can_rx_id := dl.get_can_receive_id(proto.short_name)) is not None:
                     rich.print(

odxtools/commrelation.py

@@ -9,22 +9,23 @@ 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: Description | None
+    description: Description | None = None
     relation_type: str
-    diag_comm_ref: OdxLinkRef | None
-    diag_comm_snref: str | None
-    in_param_if_snref: str | None
-    #in_param_if_snpathref: Optional[str] # TODO
-    out_param_if_snref: str | None
-    #out_param_if_snpathref: Optional[str] # TODO
-    value_type_raw: CommRelationValueType | None
+    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:
@@ -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"))

odxtools/companydata.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,34 +7,34 @@ 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: CompanySpecificInfo | None
+    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,

odxtools/companydocinfo.py

@@ -1,22 +1,23 @@
 # SPDX-License-Identifier: MIT
-from dataclasses import dataclass
+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: OdxLinkRef | None
-    doc_label: str | None
-    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:
@@ -27,16 +28,13 @@ class CompanyDocInfo:
         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,

odxtools/companyrevisioninfo.py

@@ -5,26 +5,26 @@ 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: str | None
-    state: str | None
+    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")
 

odxtools/companyspecificinfo.py

@@ -1,30 +1,28 @@
 # SPDX-License-Identifier: MIT
-from dataclasses import dataclass
+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)
 

odxtools/comparam.py

@@ -6,13 +6,14 @@ 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,11 +28,11 @@ 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)

odxtools/comparaminstance.py

@@ -9,11 +9,12 @@ 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.
@@ -21,9 +22,9 @@ class ComparamInstance:
     Be aware that the ODX specification calls this class COMPARAM-REF!
     """
     value: str | ComplexValue
-    description: Description | None
-    protocol_snref: str | None
-    prot_stack_snref: str | None
+    description: Description | None = None
+    protocol_snref: str | None = None
+    prot_stack_snref: str | None = None
     spec_ref: OdxLinkRef
 
     @property
@@ -35,9 +36,8 @@ 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
@@ -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:
@@ -133,7 +133,7 @@ class ComparamInstance:
             return None
 
         result = value_list[idx]
-        if result is None and isinstance(subparam, Comparam | ComplexComparam):
+        if result is None and isinstance(subparam, (Comparam, ComplexComparam)):
             result = subparam.physical_default_value
         if not isinstance(result, str):
             odxraise()

odxtools/comparamspec.py

@@ -1,11 +1,12 @@
 # SPDX-License-Identifier: MIT
-from dataclasses import dataclass
+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,21 +15,19 @@ 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")
         ])