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

odxtools/comparamsubset.py

@@ -1,6 +1,6 @@
 # SPDX-License-Identifier: MIT
-from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Dict, List, Optional
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, Any
 from xml.etree import ElementTree
 
 from .comparam import Comparam
@@ -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: Optional[UnitSpec]
-    category: Optional[str]  # mandatory in ODX 2.2, but non-existent in ODX 2.0
+    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,
@@ -64,7 +56,7 @@ class ComparamSubset(OdxCategory):
             unit_spec=unit_spec,
             **kwargs)
 
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         odxlinks = super()._build_odxlinks()
 
         for comparam in self.comparams:

odxtools/complexcomparam.py

@@ -1,16 +1,17 @@
 # SPDX-License-Identifier: MIT
-from dataclasses import dataclass
-from typing import Any, Dict, List, Optional, Union
+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
 
-ComplexValue = List[Union[str, "ComplexValue"]]
+ComplexValue = list[Union[str, "ComplexValue"]]
 
 
 def create_complex_value_from_et(et_element: ElementTree.Element) -> ComplexValue:
@@ -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: Optional[ComplexValue]
-    allow_multiple_values_raw: Optional[bool]
+    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,14 +61,14 @@ 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
 
         # extract the complex physical default value. (what's the
         # purpose of this? the sub-parameters can define their own
         # default values if a default is desired...)
-        complex_physical_default_value: Optional[ComplexValue] = None
+        complex_physical_default_value: ComplexValue | None = None
         if (cpdv_elem := et_element.find("COMPLEX-PHYSICAL-DEFAULT-VALUE")) is not None:
             complex_physical_default_value = create_complex_value_from_et(cpdv_elem)
 
@@ -80,7 +80,7 @@ class ComplexComparam(BaseComparam):
             allow_multiple_values_raw=allow_multiple_values_raw,
             **kwargs)
 
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         odxlinks = super()._build_odxlinks()
         for subparam in self.subparams:
             odxlinks.update(subparam._build_odxlinks())

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

@@ -1,6 +1,6 @@
 # SPDX-License-Identifier: MIT
 import typing
-from typing import List, Optional, runtime_checkable
+from typing import runtime_checkable
 
 from .codec import Codec
 from .decodestate import DecodeState
@@ -22,20 +22,20 @@ class CompositeCodec(Codec, typing.Protocol):
     """
 
     @property
-    def parameters(self) -> List[Parameter]:
+    def parameters(self) -> list[Parameter]:
         return []
 
     @property
-    def required_parameters(self) -> List[Parameter]:
+    def required_parameters(self) -> list[Parameter]:
         return []
 
     @property
-    def free_parameters(self) -> List[Parameter]:
+    def free_parameters(self) -> list[Parameter]:
         return []
 
 
 # some helper functions useful for composite codec objects
-def composite_codec_get_static_bit_length(codec: CompositeCodec) -> Optional[int]:
+def composite_codec_get_static_bit_length(codec: CompositeCodec) -> int | None:
     """Compute the length of a composite codec object in bits
 
     This is basically the sum of the lengths of all parameters. If the
@@ -59,7 +59,7 @@ def composite_codec_get_static_bit_length(codec: CompositeCodec) -> Optional[int
     return byte_length * 8
 
 
-def composite_codec_get_required_parameters(codec: CompositeCodec) -> List[Parameter]:
+def composite_codec_get_required_parameters(codec: CompositeCodec) -> list[Parameter]:
     """Return the list of parameters which are required to be
     specified for encoding the composite codec object
 
@@ -68,7 +68,7 @@ def composite_codec_get_required_parameters(codec: CompositeCodec) -> List[Param
     return [p for p in codec.parameters if p.is_required]
 
 
-def composite_codec_get_free_parameters(codec: CompositeCodec) -> List[Parameter]:
+def composite_codec_get_free_parameters(codec: CompositeCodec) -> list[Parameter]:
     """Return the list of parameters which can be freely specified by
     the user when encoding the composite codec object
 
@@ -92,7 +92,7 @@ def composite_codec_get_coded_const_prefix(codec: CompositeCodec,
     return encode_state.coded_message
 
 
-def composite_codec_encode_into_pdu(codec: CompositeCodec, physical_value: Optional[ParameterValue],
+def composite_codec_encode_into_pdu(codec: CompositeCodec, physical_value: ParameterValue | None,
                                     encode_state: EncodeState) -> None:
     from .parameters.lengthkeyparameter import LengthKeyParameter
     from .parameters.tablekeyparameter import TableKeyParameter

odxtools/compumethods/compucodecompumethod.py

@@ -1,10 +1,10 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import List, Optional, cast
+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
 
@@ -20,25 +20,25 @@ class CompuCodeCompuMethod(CompuMethod):
     """
 
     @property
-    def internal_to_phys_code(self) -> Optional[ProgCode]:
+    def internal_to_phys_code(self) -> ProgCode | None:
         if self.compu_internal_to_phys is None:
             return None
 
         return self.compu_internal_to_phys.prog_code
 
     @property
-    def phys_to_internal_code(self) -> Optional[ProgCode]:
+    def phys_to_internal_code(self) -> ProgCode | None:
         if self.compu_phys_to_internal is None:
             return None
 
         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

@@ -1,20 +1,19 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import Optional
 from xml.etree import ElementTree
 
 from ..odxtypes import AtomicOdxType, DataType
 
 
-@dataclass
+@dataclass(kw_only=True)
 class CompuConst:
-    v: Optional[str]
-    vt: Optional[str]
+    v: str | None = None
+    vt: str | None = None
 
     data_type: DataType
 
     @property
-    def value(self) -> Optional[AtomicOdxType]:
+    def value(self) -> AtomicOdxType | None:
         return self._value
 
     @staticmethod
@@ -26,6 +25,6 @@ class CompuConst:
         return CompuConst(v=v, vt=vt, data_type=data_type)
 
     def __post_init__(self) -> None:
-        self._value: Optional[AtomicOdxType] = self.vt
+        self._value: AtomicOdxType | None = self.vt
         if self.v is not None:
             self._value = self.data_type.from_string(self.v)

odxtools/compumethods/compudefaultvalue.py

@@ -1,6 +1,5 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import Optional
 from xml.etree import ElementTree
 
 from ..odxtypes import DataType
@@ -9,9 +8,9 @@ from .compuconst import CompuConst
 from .compuinversevalue import CompuInverseValue
 
 
-@dataclass
+@dataclass(kw_only=True)
 class CompuDefaultValue(CompuConst):
-    compu_inverse_value: Optional[CompuInverseValue]
+    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 typing import Any, Dict, List, Optional
+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: Optional[ProgCode]
-    compu_default_value: Optional[CompuDefaultValue]
+    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:
@@ -39,7 +40,7 @@ class CompuInternalToPhys:
         return CompuInternalToPhys(
             compu_scales=compu_scales, prog_code=prog_code, compu_default_value=compu_default_value)
 
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         result = {}
 
         if self.prog_code is not None:

odxtools/compumethods/compumethod.py

@@ -1,10 +1,11 @@
 # 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 ..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: Optional[CompuInternalToPhys]
-    compu_phys_to_internal: Optional[CompuPhysToInternal]
+    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,
@@ -67,7 +68,7 @@ class CompuMethod:
             physical_type=physical_type,
             internal_type=internal_type)
 
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         result = {}
 
         if self.compu_internal_to_phys is not None:

odxtools/compumethods/compuphystointernal.py

@@ -1,9 +1,10 @@
 # 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 ..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: Optional[ProgCode]
-    compu_default_value: Optional[CompuDefaultValue]
+    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:
@@ -39,7 +40,7 @@ class CompuPhysToInternal:
         return CompuPhysToInternal(
             compu_scales=compu_scales, prog_code=prog_code, compu_default_value=compu_default_value)
 
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         result = {}
 
         if self.prog_code is not None:

odxtools/compumethods/compurationalcoeffs.py

@@ -1,22 +1,22 @@
 # SPDX-License-Identifier: MIT
-from dataclasses import dataclass
-from typing import List, Union, cast
+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[Union[int, float]]
-    denominators: List[Union[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

@@ -1,10 +1,9 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import List, Optional
 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
@@ -12,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: Optional[str]
-    description: Optional[Description]
-    lower_limit: Optional[Limit]
-    upper_limit: Optional[Limit]
-    compu_inverse_value: Optional[CompuInverseValue]
-    compu_const: Optional[CompuConst]
-    compu_rational_coeffs: Optional[CompuRationalCoeffs]
+    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
@@ -38,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:
@@ -56,10 +55,10 @@ class CompuScale:
         if (cce := et_element.find("COMPU-CONST")) is not None:
             compu_const = CompuConst.compuvalue_from_et(cce, data_type=range_type)
 
-        compu_rational_coeffs: Optional[CompuRationalCoeffs] = None
+        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,