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

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

odxtools/comparamsubset.py

@@ -1,5 +1,5 @@
 # SPDX-License-Identifier: MIT
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from typing import TYPE_CHECKING, Any
 from xml.etree import ElementTree
 
@@ -8,7 +8,8 @@ from .complexcomparam import ComplexComparam
 from .dataobjectproperty import DataObjectProperty
 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 .snrefcontext import SnRefContext
 from .unitspec import UnitSpec
 from .utils import dataclass_fields_asdict
@@ -17,44 +18,35 @@ if TYPE_CHECKING:
     from .database import Database
 
 
-@dataclass
+@dataclass(kw_only=True)
 class ComparamSubset(OdxCategory):
-    comparams: NamedItemList[Comparam]
-    complex_comparams: NamedItemList[ComplexComparam]
-    data_object_props: NamedItemList[DataObjectProperty]
-    unit_spec: UnitSpec | None
+    comparams: NamedItemList[Comparam] = field(default_factory=NamedItemList)
+    complex_comparams: NamedItemList[ComplexComparam] = field(default_factory=NamedItemList)
+    data_object_props: NamedItemList[DataObjectProperty] = field(default_factory=NamedItemList)
+    unit_spec: UnitSpec | None = None
     category: str | None  # mandatory in ODX 2.2, but non-existent in ODX 2.0
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element,
-                doc_frags: list[OdxDocFragment]) -> "ComparamSubset":
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "ComparamSubset":
 
         category_attrib = et_element.attrib.get("CATEGORY")
 
-        # In ODX 2.0, COMPARAM-SPEC is used, whereas in ODX 2.2, it
-        # refers to something else and has been replaced by
-        # COMPARAM-SUBSET.
-        # - If the 'CATEGORY' attribute is missing (ODX 2.0), use
-        #   COMPARAM_SPEC,
-        # - else (ODX 2.2), use COMPARAM_SUBSET.
-        doc_type = DocType.COMPARAM_SUBSET if category_attrib is not None else DocType.COMPARAM_SPEC
-        base_obj = OdxCategory.category_from_et(et_element, doc_frags, doc_type=doc_type)
-        doc_frags = base_obj.odx_id.doc_fragments
+        base_obj = OdxCategory.from_et(et_element, context)
         kwargs = dataclass_fields_asdict(base_obj)
 
         comparams = NamedItemList(
-            [Comparam.from_et(el, doc_frags) for el in et_element.iterfind("COMPARAMS/COMPARAM")])
+            [Comparam.from_et(el, context) for el in et_element.iterfind("COMPARAMS/COMPARAM")])
         complex_comparams = NamedItemList([
-            ComplexComparam.from_et(el, doc_frags)
+            ComplexComparam.from_et(el, context)
             for el in et_element.iterfind("COMPLEX-COMPARAMS/COMPLEX-COMPARAM")
         ])
         data_object_props = NamedItemList([
-            DataObjectProperty.from_et(el, doc_frags)
+            DataObjectProperty.from_et(el, context)
             for el in et_element.iterfind("DATA-OBJECT-PROPS/DATA-OBJECT-PROP")
         ])
         unit_spec = None
         if (unit_spec_elem := et_element.find("UNIT-SPEC")) is not None:
-            unit_spec = UnitSpec.from_et(unit_spec_elem, doc_frags)
+            unit_spec = UnitSpec.from_et(unit_spec_elem, context)
 
         return ComparamSubset(
             category=category_attrib,

odxtools/complexcomparam.py

@@ -1,11 +1,12 @@
 # SPDX-License-Identifier: MIT
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from typing import Any, Union
 from xml.etree import ElementTree
 
 from .basecomparam import BaseComparam
 from .nameditemlist import NamedItemList
-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 .utils import dataclass_fields_asdict
@@ -23,20 +24,19 @@ def create_complex_value_from_et(et_element: ElementTree.Element) -> ComplexValu
     return result
 
 
-@dataclass
+@dataclass(kw_only=True)
 class ComplexComparam(BaseComparam):
-    subparams: NamedItemList[BaseComparam]
-    physical_default_value: ComplexValue | None
-    allow_multiple_values_raw: bool | None
+    subparams: NamedItemList[BaseComparam] = field(default_factory=NamedItemList)
+    physical_default_value: ComplexValue | None = None
+    allow_multiple_values_raw: bool | None = None
 
     @property
     def allow_multiple_values(self) -> bool:
         return self.allow_multiple_values_raw is True
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element,
-                doc_frags: list[OdxDocFragment]) -> "ComplexComparam":
-        kwargs = dataclass_fields_asdict(BaseComparam.from_et(et_element, doc_frags))
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "ComplexComparam":
+        kwargs = dataclass_fields_asdict(BaseComparam.from_et(et_element, context))
 
         # to avoid a cyclic import, create_any_comparam_from_et cannot
         # be imported globally. TODO: figure out if this has
@@ -61,7 +61,7 @@ class ComplexComparam(BaseComparam):
             if elems[i].tag not in ("COMPARAM", "COMPLEX-COMPARAM"):
                 break
 
-            subparam = create_any_comparam_from_et(elems[i], doc_frags)
+            subparam = create_any_comparam_from_et(elems[i], context)
             subparams.append(subparam)
             i += 1
 

odxtools/complexdop.py

@@ -4,7 +4,7 @@ from dataclasses import dataclass
 from .dopbase import DopBase
 
 
-@dataclass
+@dataclass(kw_only=True)
 class ComplexDop(DopBase):
     """Base class for all complex data object properties.
 

odxtools/compositecodec.py

@@ -84,7 +84,7 @@ def composite_codec_get_coded_const_prefix(codec: CompositeCodec,
 
     for param in codec.parameters:
         if (isinstance(param, MatchingRequestParameter) and param.request_byte_position < len(request_prefix)) or \
-            isinstance(param, CodedConstParameter|PhysicalConstantParameter) :
+            isinstance(param, (CodedConstParameter, PhysicalConstantParameter)):
             param.encode_into_pdu(physical_value=None, encode_state=encode_state)
         else:
             break
@@ -132,7 +132,7 @@ def composite_codec_encode_into_pdu(codec: CompositeCodec, physical_value: Param
             # the ODX is located last in the PDU...
             encode_state.is_end_of_pdu = orig_is_end_of_pdu
 
-        if isinstance(param, LengthKeyParameter | TableKeyParameter):
+        if isinstance(param, (LengthKeyParameter, TableKeyParameter)):
             # At this point, we encode a placeholder value for length-
             # and table keys, since these can be specified
             # implicitly (i.e., by means of parameters that use
@@ -159,7 +159,7 @@ def composite_codec_encode_into_pdu(codec: CompositeCodec, physical_value: Param
     # because we allow these to be defined implicitly (i.e. they
     # are defined by their respective users)
     for param in codec.parameters:
-        if not isinstance(param, LengthKeyParameter | TableKeyParameter):
+        if not isinstance(param, (LengthKeyParameter, TableKeyParameter)):
             # the current parameter is neither a length- nor a table key
             continue
 

odxtools/compumethods/compucodecompumethod.py

@@ -4,7 +4,7 @@ from typing import cast
 from xml.etree import ElementTree
 
 from ..exceptions import DecodeError, EncodeError, odxassert, odxraise
-from ..odxlink import OdxDocFragment
+from ..odxdoccontext import OdxDocContext
 from ..odxtypes import AtomicOdxType, DataType
 from ..progcode import ProgCode
 from ..utils import dataclass_fields_asdict
@@ -12,7 +12,7 @@ from .compucategory import CompuCategory
 from .compumethod import CompuMethod
 
 
-@dataclass
+@dataclass(kw_only=True)
 class CompuCodeCompuMethod(CompuMethod):
     """A compu method specifies the tranfer functions using Java bytecode
 
@@ -34,11 +34,11 @@ class CompuCodeCompuMethod(CompuMethod):
         return self.compu_phys_to_internal.prog_code
 
     @staticmethod
-    def compu_method_from_et(et_element: ElementTree.Element, doc_frags: list[OdxDocFragment], *,
+    def compu_method_from_et(et_element: ElementTree.Element, context: OdxDocContext, *,
                              internal_type: DataType,
                              physical_type: DataType) -> "CompuCodeCompuMethod":
         cm = CompuMethod.compu_method_from_et(
-            et_element, doc_frags, internal_type=internal_type, physical_type=physical_type)
+            et_element, context, internal_type=internal_type, physical_type=physical_type)
         kwargs = dataclass_fields_asdict(cm)
 
         return CompuCodeCompuMethod(**kwargs)

odxtools/compumethods/compuconst.py

@@ -5,10 +5,10 @@ from xml.etree import ElementTree
 from ..odxtypes import AtomicOdxType, DataType
 
 
-@dataclass
+@dataclass(kw_only=True)
 class CompuConst:
-    v: str | None
-    vt: str | None
+    v: str | None = None
+    vt: str | None = None
 
     data_type: DataType
 

odxtools/compumethods/compudefaultvalue.py

@@ -8,9 +8,9 @@ from .compuconst import CompuConst
 from .compuinversevalue import CompuInverseValue
 
 
-@dataclass
+@dataclass(kw_only=True)
 class CompuDefaultValue(CompuConst):
-    compu_inverse_value: CompuInverseValue | None
+    compu_inverse_value: CompuInverseValue | None = None
 
     @staticmethod
     def compuvalue_from_et(et_element: ElementTree.Element, *,

odxtools/compumethods/compuinternaltophys.py

@@ -1,9 +1,10 @@
 # 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 ..odxtypes import DataType
 from ..progcode import ProgCode
 from ..snrefcontext import SnRefContext
@@ -11,25 +12,25 @@ from .compudefaultvalue import CompuDefaultValue
 from .compuscale import CompuScale
 
 
-@dataclass
+@dataclass(kw_only=True)
 class CompuInternalToPhys:
-    compu_scales: list[CompuScale]
-    prog_code: ProgCode | None
-    compu_default_value: CompuDefaultValue | None
+    compu_scales: list[CompuScale] = field(default_factory=list)
+    prog_code: ProgCode | None = None
+    compu_default_value: CompuDefaultValue | None = None
 
     @staticmethod
-    def compu_internal_to_phys_from_et(et_element: ElementTree.Element,
-                                       doc_frags: list[OdxDocFragment], *, internal_type: DataType,
+    def compu_internal_to_phys_from_et(et_element: ElementTree.Element, context: OdxDocContext, *,
+                                       internal_type: DataType,
                                        physical_type: DataType) -> "CompuInternalToPhys":
         compu_scales = [
             CompuScale.compuscale_from_et(
-                cse, doc_frags, domain_type=internal_type, range_type=physical_type)
+                cse, context, domain_type=internal_type, range_type=physical_type)
             for cse in et_element.iterfind("COMPU-SCALES/COMPU-SCALE")
         ]
 
         prog_code = None
         if (pce := et_element.find("PROG-CODE")) is not None:
-            prog_code = ProgCode.from_et(pce, doc_frags)
+            prog_code = ProgCode.from_et(pce, context)
 
         compu_default_value = None
         if (cdve := et_element.find("COMPU-DEFAULT-VALUE")) is not None:

odxtools/compumethods/compumethod.py

@@ -4,7 +4,8 @@ from typing import Any
 from xml.etree import ElementTree
 
 from ..exceptions import odxraise
-from ..odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
+from ..odxdoccontext import OdxDocContext
+from ..odxlink import OdxLinkDatabase, OdxLinkId
 from ..odxtypes import AtomicOdxType, DataType
 from ..snrefcontext import SnRefContext
 from .compucategory import CompuCategory
@@ -12,7 +13,7 @@ from .compuinternaltophys import CompuInternalToPhys
 from .compuphystointernal import CompuPhysToInternal
 
 
-@dataclass
+@dataclass(kw_only=True)
 class CompuMethod:
     """A compu method translates between the internal representation
     of a value and their physical representation.
@@ -31,14 +32,14 @@ class CompuMethod:
     """
 
     category: CompuCategory
-    compu_internal_to_phys: CompuInternalToPhys | None
-    compu_phys_to_internal: CompuPhysToInternal | None
+    compu_internal_to_phys: CompuInternalToPhys | None = None
+    compu_phys_to_internal: CompuPhysToInternal | None = None
 
     physical_type: DataType
     internal_type: DataType
 
     @staticmethod
-    def compu_method_from_et(et_element: ElementTree.Element, doc_frags: list[OdxDocFragment], *,
+    def compu_method_from_et(et_element: ElementTree.Element, context: OdxDocContext, *,
                              internal_type: DataType, physical_type: DataType) -> "CompuMethod":
         cat_text = et_element.findtext("CATEGORY")
         if cat_text is None:
@@ -54,11 +55,11 @@ class CompuMethod:
         compu_internal_to_phys = None
         if (citp_elem := et_element.find("COMPU-INTERNAL-TO-PHYS")) is not None:
             compu_internal_to_phys = CompuInternalToPhys.compu_internal_to_phys_from_et(
-                citp_elem, doc_frags, internal_type=internal_type, physical_type=physical_type)
+                citp_elem, context, internal_type=internal_type, physical_type=physical_type)
         compu_phys_to_internal = None
         if (cpti_elem := et_element.find("COMPU-PHYS-TO-INTERNAL")) is not None:
             compu_phys_to_internal = CompuPhysToInternal.compu_phys_to_internal_from_et(
-                cpti_elem, doc_frags, internal_type=internal_type, physical_type=physical_type)
+                cpti_elem, context, internal_type=internal_type, physical_type=physical_type)
 
         return CompuMethod(
             category=category,

odxtools/compumethods/compuphystointernal.py

@@ -1,9 +1,10 @@
 # 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 ..odxtypes import DataType
 from ..progcode import ProgCode
 from ..snrefcontext import SnRefContext
@@ -11,25 +12,25 @@ from .compudefaultvalue import CompuDefaultValue
 from .compuscale import CompuScale
 
 
-@dataclass
+@dataclass(kw_only=True)
 class CompuPhysToInternal:
-    compu_scales: list[CompuScale]
-    prog_code: ProgCode | None
-    compu_default_value: CompuDefaultValue | None
+    compu_scales: list[CompuScale] = field(default_factory=list)
+    prog_code: ProgCode | None = None
+    compu_default_value: CompuDefaultValue | None = None
 
     @staticmethod
-    def compu_phys_to_internal_from_et(et_element: ElementTree.Element,
-                                       doc_frags: list[OdxDocFragment], *, internal_type: DataType,
+    def compu_phys_to_internal_from_et(et_element: ElementTree.Element, context: OdxDocContext, *,
+                                       internal_type: DataType,
                                        physical_type: DataType) -> "CompuPhysToInternal":
         compu_scales = [
             CompuScale.compuscale_from_et(
-                cse, doc_frags, domain_type=physical_type, range_type=internal_type)
+                cse, context, domain_type=physical_type, range_type=internal_type)
             for cse in et_element.iterfind("COMPU-SCALES/COMPU-SCALE")
         ]
 
         prog_code = None
         if (pce := et_element.find("PROG-CODE")) is not None:
-            prog_code = ProgCode.from_et(pce, doc_frags)
+            prog_code = ProgCode.from_et(pce, context)
 
         compu_default_value = None
         if (cdve := et_element.find("COMPU-DEFAULT-VALUE")) is not None:

odxtools/compumethods/compurationalcoeffs.py

@@ -1,22 +1,22 @@
 # SPDX-License-Identifier: MIT
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from typing import cast
 from xml.etree import ElementTree
 
 from ..exceptions import odxassert, odxrequire
-from ..odxlink import OdxDocFragment
+from ..odxdoccontext import OdxDocContext
 from ..odxtypes import DataType
 
 
-@dataclass
+@dataclass(kw_only=True)
 class CompuRationalCoeffs:
     value_type: DataType
 
-    numerators: list[int | float]
-    denominators: list[int | float]
+    numerators: list[int | float] = field(default_factory=list)
+    denominators: list[int | float] = field(default_factory=list)
 
     @staticmethod
-    def coeffs_from_et(et_element: ElementTree.Element, doc_frags: list[OdxDocFragment], *,
+    def coeffs_from_et(et_element: ElementTree.Element, context: OdxDocContext, *,
                        value_type: DataType) -> "CompuRationalCoeffs":
         odxassert(
             value_type

odxtools/compumethods/compuscale.py

@@ -3,7 +3,7 @@ from dataclasses import dataclass
 from xml.etree import ElementTree
 
 from ..description import Description
-from ..odxlink import OdxDocFragment
+from ..odxdoccontext import OdxDocContext
 from ..odxtypes import AtomicOdxType, DataType
 from .compuconst import CompuConst
 from .compuinversevalue import CompuInverseValue
@@ -11,18 +11,18 @@ from .compurationalcoeffs import CompuRationalCoeffs
 from .limit import Limit
 
 
-@dataclass
+@dataclass(kw_only=True)
 class CompuScale:
     """A COMPU-SCALE represents one value range of a COMPU-METHOD.
     """
 
-    short_label: str | None
-    description: Description | None
-    lower_limit: Limit | None
-    upper_limit: Limit | None
-    compu_inverse_value: CompuInverseValue | None
-    compu_const: CompuConst | None
-    compu_rational_coeffs: CompuRationalCoeffs | None
+    short_label: str | None = None
+    description: Description | None = None
+    lower_limit: Limit | None = None
+    upper_limit: Limit | None = None
+    compu_inverse_value: CompuInverseValue | None = None
+    compu_const: CompuConst | None = None
+    compu_rational_coeffs: CompuRationalCoeffs | None = None
 
     # the following two attributes are not specified for COMPU-SCALE
     # tags in the XML, but they are required to do anything useful
@@ -37,15 +37,15 @@ class CompuScale:
     range_type: DataType
 
     @staticmethod
-    def compuscale_from_et(et_element: ElementTree.Element, doc_frags: list[OdxDocFragment], *,
+    def compuscale_from_et(et_element: ElementTree.Element, context: OdxDocContext, *,
                            domain_type: DataType, range_type: DataType) -> "CompuScale":
         short_label = et_element.findtext("SHORT-LABEL")
-        description = Description.from_et(et_element.find("DESC"), doc_frags)
+        description = Description.from_et(et_element.find("DESC"), context)
 
         lower_limit = Limit.limit_from_et(
-            et_element.find("LOWER-LIMIT"), doc_frags, value_type=domain_type)
+            et_element.find("LOWER-LIMIT"), context, value_type=domain_type)
         upper_limit = Limit.limit_from_et(
-            et_element.find("UPPER-LIMIT"), doc_frags, value_type=domain_type)
+            et_element.find("UPPER-LIMIT"), context, value_type=domain_type)
 
         compu_inverse_value = None
         if (cive := et_element.find("COMPU-INVERSE-VALUE")) is not None:
@@ -58,7 +58,7 @@ class CompuScale:
         compu_rational_coeffs: CompuRationalCoeffs | None = None
         if (crc_elem := et_element.find("COMPU-RATIONAL-COEFFS")) is not None:
             compu_rational_coeffs = CompuRationalCoeffs.coeffs_from_et(
-                crc_elem, doc_frags, value_type=range_type)
+                crc_elem, context, value_type=range_type)
 
         return CompuScale(
             short_label=short_label,