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

odxtools/compumethods/linearsegment.py

@@ -7,7 +7,7 @@ from .compuscale import CompuScale
 from .limit import Limit
 
 
-@dataclass
+@dataclass(kw_only=True)
 class LinearSegment:
     """Helper class to represent a segment of a piecewise-linear interpolation.
 
@@ -23,8 +23,8 @@ class LinearSegment:
     offset: float
     factor: float
     denominator: float
-    internal_lower_limit: Limit | None
-    internal_upper_limit: Limit | None
+    internal_lower_limit: Limit | None = None
+    internal_upper_limit: Limit | None = None
 
     inverse_value: int | float  # value used as inverse if factor is 0
 
@@ -54,7 +54,7 @@ class LinearSegment:
         inverse_value: int | float = 0
         if scale.compu_inverse_value is not None:
             x = odxrequire(scale.compu_inverse_value).value
-            if not isinstance(x, int | float):
+            if not isinstance(x, (int, float)):
                 odxraise(f"Non-numeric COMPU-INVERSE-VALUE specified ({x!r})")
             inverse_value = x
 
@@ -75,7 +75,7 @@ class LinearSegment:
         self.__compute_physical_limits()
 
     def convert_internal_to_physical(self, internal_value: AtomicOdxType) -> float | int:
-        if not isinstance(internal_value, int | float):
+        if not isinstance(internal_value, (int, float)):
             odxraise(f"Internal values of linear compumethods must "
                      f"either be int or float (is: {type(internal_value).__name__})")
 
@@ -90,7 +90,7 @@ class LinearSegment:
         return result
 
     def convert_physical_to_internal(self, physical_value: AtomicOdxType) -> float | int:
-        if not isinstance(physical_value, int | float):
+        if not isinstance(physical_value, (int, float)):
             odxraise(f"Physical values of linear compumethods must "
                      f"either be int or float (is: {type(physical_value).__name__})")
 
@@ -151,7 +151,7 @@ class LinearSegment:
         # Do type checks
         expected_type = self.physical_type.python_type
         if issubclass(expected_type, float):
-            if not isinstance(physical_value, int | float):
+            if not isinstance(physical_value, (int, float)):
                 return False
         else:
             if not isinstance(physical_value, expected_type):
@@ -172,7 +172,7 @@ class LinearSegment:
         # Do type checks
         expected_type = self.internal_type.python_type
         if issubclass(expected_type, float):
-            if not isinstance(internal_value, int | float):
+            if not isinstance(internal_value, (int, float)):
                 return False
         else:
             if not isinstance(internal_value, expected_type):

odxtools/compumethods/ratfunccompumethod.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 ..utils import dataclass_fields_asdict
 from .compucategory import CompuCategory
@@ -12,7 +12,7 @@ from .compumethod import CompuMethod
 from .ratfuncsegment import RatFuncSegment
 
 
-@dataclass
+@dataclass(kw_only=True)
 class RatFuncCompuMethod(CompuMethod):
     """A compu method using a rational function
 
@@ -34,11 +34,11 @@ class RatFuncCompuMethod(CompuMethod):
         return self._phys_to_int_segment
 
     @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) -> "RatFuncCompuMethod":
         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 RatFuncCompuMethod(**kwargs)

odxtools/compumethods/ratfuncsegment.py

@@ -1,5 +1,5 @@
 # SPDX-License-Identifier: MIT
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 
 from ..exceptions import odxraise, odxrequire
 from ..odxtypes import AtomicOdxType, DataType
@@ -7,17 +7,17 @@ from .compuscale import CompuScale
 from .limit import Limit
 
 
-@dataclass
+@dataclass(kw_only=True)
 class RatFuncSegment:
     """Helper class to represent a segment of a piecewise rational function.
     """
     value_type: DataType
 
-    numerator_coeffs: list[int | float]
-    denominator_coeffs: list[int | float]
+    numerator_coeffs: list[int | float] = field(default_factory=list)
+    denominator_coeffs: list[int | float] = field(default_factory=list)
 
-    lower_limit: Limit | None
-    upper_limit: Limit | None
+    lower_limit: Limit | None = None
+    upper_limit: Limit | None = None
 
     @staticmethod
     def from_compu_scale(scale: CompuScale, value_type: DataType) -> "RatFuncSegment":
@@ -39,7 +39,7 @@ class RatFuncSegment:
             value_type=scale.range_type)
 
     def convert(self, value: AtomicOdxType) -> float | int:
-        if not isinstance(value, int | float):
+        if not isinstance(value, (int, float)):
             odxraise(f"Internal values of linear compumethods must "
                      f"either be int or float (is: {type(value).__name__})")
 
@@ -69,7 +69,7 @@ class RatFuncSegment:
         # Do type checks
         expected_type = self.value_type.python_type
         if issubclass(expected_type, float):
-            if not isinstance(value, int | float):
+            if not isinstance(value, (int, float)):
                 return False
         else:
             if not isinstance(value, expected_type):

odxtools/compumethods/scalelinearcompumethod.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 ..utils import dataclass_fields_asdict
 from .compucategory import CompuCategory
@@ -13,7 +13,7 @@ from .intervaltype import IntervalType
 from .linearsegment import LinearSegment
 
 
-@dataclass
+@dataclass(kw_only=True)
 class ScaleLinearCompuMethod(CompuMethod):
     """A piecewise linear compu method which may feature discontinuities.
 
@@ -25,11 +25,11 @@ class ScaleLinearCompuMethod(CompuMethod):
         return self._segments
 
     @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) -> "ScaleLinearCompuMethod":
         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 ScaleLinearCompuMethod(**kwargs)
@@ -100,7 +100,7 @@ class ScaleLinearCompuMethod(CompuMethod):
                 self._is_invertible = False
                 break
 
-            if not isinstance(x, int | float):
+            if not isinstance(x, (int, float)):
                 odxraise("Linear segments must use int or float for all quantities")
 
             # the respective function value at the interval's

odxtools/compumethods/scaleratfunccompumethod.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 ..utils import dataclass_fields_asdict
 from .compucategory import CompuCategory
@@ -12,7 +12,7 @@ from .compumethod import CompuMethod
 from .ratfuncsegment import RatFuncSegment
 
 
-@dataclass
+@dataclass(kw_only=True)
 class ScaleRatFuncCompuMethod(CompuMethod):
     """A compu method using a piecewise rational function
 
@@ -28,11 +28,11 @@ class ScaleRatFuncCompuMethod(CompuMethod):
         return self._phys_to_int_segments
 
     @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) -> "ScaleRatFuncCompuMethod":
         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 ScaleRatFuncCompuMethod(**kwargs)

odxtools/compumethods/tabintpcompumethod.py

@@ -3,7 +3,7 @@ from dataclasses import dataclass
 from xml.etree import ElementTree
 
 from ..exceptions import DecodeError, EncodeError, odxassert, odxraise, odxrequire
-from ..odxlink import OdxDocFragment
+from ..odxdoccontext import OdxDocContext
 from ..odxtypes import AtomicOdxType, DataType
 from ..utils import dataclass_fields_asdict
 from .compucategory import CompuCategory
@@ -12,7 +12,7 @@ from .intervaltype import IntervalType
 from .limit import Limit
 
 
-@dataclass
+@dataclass(kw_only=True)
 class TabIntpCompuMethod(CompuMethod):
     """A table-based interpolated compu method provides a continuous
     transfer function based on piecewise linear interpolation.
@@ -60,11 +60,11 @@ class TabIntpCompuMethod(CompuMethod):
         return self._physical_upper_limit
 
     @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) -> "TabIntpCompuMethod":
         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 TabIntpCompuMethod(**kwargs)
@@ -79,10 +79,10 @@ class TabIntpCompuMethod(CompuMethod):
             internal_point = odxrequire(scale.lower_limit).value
             physical_point = odxrequire(scale.compu_const).value
 
-            if not isinstance(internal_point, float | int):
+            if not isinstance(internal_point, (float, int)):
                 odxraise("The type of values of tab-intp compumethods must "
                          "either int or float")
-            if not isinstance(physical_point, float | int):
+            if not isinstance(physical_point, (float, int)):
                 odxraise("The type of values of tab-intp compumethods must "
                          "either int or float")
 
@@ -140,13 +140,13 @@ class TabIntpCompuMethod(CompuMethod):
         return None
 
     def convert_physical_to_internal(self, physical_value: AtomicOdxType) -> AtomicOdxType:
-        if not isinstance(physical_value, int | float):
+        if not isinstance(physical_value, (int, float)):
             odxraise("The type of values of tab-intp compumethods must "
                      "either int or float", EncodeError)
             return None
 
         odxassert(
-            isinstance(physical_value, int | float),
+            isinstance(physical_value, (int, float)),
             "Only integers and floats can be piecewise linearly interpolated", EncodeError)
         result = self.__piecewise_linear_interpolate(physical_value, self._physical_points,
                                                      self._internal_points)
@@ -161,14 +161,14 @@ class TabIntpCompuMethod(CompuMethod):
         return res
 
     def convert_internal_to_physical(self, internal_value: AtomicOdxType) -> AtomicOdxType:
-        if not isinstance(internal_value, int | float):
+        if not isinstance(internal_value, (int, float)):
             odxraise(
                 "The internal type of values of tab-intp compumethods must "
                 "either int or float", EncodeError)
             return None
 
         odxassert(
-            isinstance(internal_value, int | float),
+            isinstance(internal_value, (int, float)),
             "Only integers and floats can be piecewise linearly interpolated", DecodeError)
 
         result = self.__piecewise_linear_interpolate(internal_value, self._internal_points,
@@ -185,14 +185,14 @@ class TabIntpCompuMethod(CompuMethod):
         return res
 
     def is_valid_physical_value(self, physical_value: AtomicOdxType) -> bool:
-        if not isinstance(physical_value, int | float):
+        if not isinstance(physical_value, (int, float)):
             return False
 
         return min(self.physical_points) <= physical_value and physical_value <= max(
             self.physical_points)
 
     def is_valid_internal_value(self, internal_value: AtomicOdxType) -> bool:
-        if not isinstance(internal_value, int | float):
+        if not isinstance(internal_value, (int, float)):
             return False
 
         return min(self.internal_points) <= internal_value and internal_value <= max(

odxtools/compumethods/texttablecompumethod.py

@@ -4,7 +4,7 @@ from typing import cast
 from xml.etree import ElementTree
 
 from ..exceptions import DecodeError, EncodeError, odxassert, odxraise, odxrequire
-from ..odxlink import OdxDocFragment
+from ..odxdoccontext import OdxDocContext
 from ..odxtypes import AtomicOdxType, DataType
 from ..utils import dataclass_fields_asdict
 from .compucategory import CompuCategory
@@ -12,7 +12,7 @@ from .compumethod import CompuMethod
 from .compuscale import CompuScale
 
 
-@dataclass
+@dataclass(kw_only=True)
 class TexttableCompuMethod(CompuMethod):
     """Text table compute methods translate numbers to human readable
     textual descriptions.
@@ -22,11 +22,11 @@ class TexttableCompuMethod(CompuMethod):
     """
 
     @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) -> "TexttableCompuMethod":
         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 TexttableCompuMethod(**kwargs)

odxtools/createanycomparam.py

@@ -2,14 +2,14 @@ from xml.etree import ElementTree
 
 from .comparam import Comparam
 from .complexcomparam import ComplexComparam
-from .odxlink import OdxDocFragment
+from .odxdoccontext import OdxDocContext
 
 
 def create_any_comparam_from_et(et_element: ElementTree.Element,
-                                doc_frags: list[OdxDocFragment]) -> Comparam | ComplexComparam:
+                                context: OdxDocContext) -> Comparam | ComplexComparam:
     if et_element.tag == "COMPARAM":
-        return Comparam.from_et(et_element, doc_frags)
+        return Comparam.from_et(et_element, context)
     elif et_element.tag == "COMPLEX-COMPARAM":
-        return ComplexComparam.from_et(et_element, doc_frags)
+        return ComplexComparam.from_et(et_element, context)
 
     raise RuntimeError(f"Unhandled communication parameter type {et_element.tag}")

odxtools/createanydiagcodedtype.py

@@ -6,22 +6,22 @@ from .exceptions import odxraise
 from .globals import xsi
 from .leadinglengthinfotype import LeadingLengthInfoType
 from .minmaxlengthtype import MinMaxLengthType
-from .odxlink import OdxDocFragment
+from .odxdoccontext import OdxDocContext
 from .paramlengthinfotype import ParamLengthInfoType
 from .standardlengthtype import StandardLengthType
 
 
 def create_any_diag_coded_type_from_et(et_element: ElementTree.Element,
-                                       doc_frags: list[OdxDocFragment]) -> DiagCodedType:
+                                       context: OdxDocContext) -> DiagCodedType:
     dct_type = et_element.get(f"{xsi}type")
     if dct_type == "LEADING-LENGTH-INFO-TYPE":
-        return LeadingLengthInfoType.from_et(et_element, doc_frags)
+        return LeadingLengthInfoType.from_et(et_element, context)
     elif dct_type == "MIN-MAX-LENGTH-TYPE":
-        return MinMaxLengthType.from_et(et_element, doc_frags)
+        return MinMaxLengthType.from_et(et_element, context)
     elif dct_type == "PARAM-LENGTH-INFO-TYPE":
-        return ParamLengthInfoType.from_et(et_element, doc_frags)
+        return ParamLengthInfoType.from_et(et_element, context)
     elif dct_type == "STANDARD-LENGTH-TYPE":
-        return StandardLengthType.from_et(et_element, doc_frags)
+        return StandardLengthType.from_et(et_element, context)
 
     odxraise(f"Unknown DIAG-CODED-TYPE {dct_type}", NotImplementedError)
-    return DiagCodedType.from_et(et_element, doc_frags)
+    return DiagCodedType.from_et(et_element, context)

odxtools/database.py

@@ -20,7 +20,8 @@ from .diaglayers.functionalgroup import FunctionalGroup
 from .diaglayers.protocol import Protocol
 from .exceptions import odxraise, odxrequire
 from .nameditemlist import NamedItemList
-from .odxlink import OdxLinkDatabase, OdxLinkId
+from .odxdoccontext import OdxDocContext
+from .odxlink import DocType, OdxDocFragment, OdxLinkDatabase, OdxLinkId
 from .snrefcontext import SnRefContext
 
 
@@ -76,10 +77,6 @@ class Database:
         self.auxiliary_files[str(aux_file_name)] = aux_file_obj
 
     def _process_xml_tree(self, root: ElementTree.Element) -> None:
-        dlcs: list[DiagLayerContainer] = []
-        comparam_subsets: list[ComparamSubset] = []
-        comparam_specs: list[ComparamSpec] = []
-
         # ODX spec version
         model_version = Version(root.attrib.get("MODEL-VERSION", "2.0"))
         if self.model_version is not None and self.model_version != model_version:
@@ -88,28 +85,33 @@ class Database:
 
         self.model_version = model_version
 
-        dlc = root.find("DIAG-LAYER-CONTAINER")
-        if dlc is not None:
-            dlcs.append(DiagLayerContainer.from_et(dlc, []))
-
-        # In ODX 2.0 there was only COMPARAM-SPEC. In ODX 2.2 the
-        # content of COMPARAM-SPEC was moved to COMPARAM-SUBSET
-        # and COMPARAM-SPEC became a container for PROT-STACKS and
-        # a PROT-STACK references a list of COMPARAM-SUBSET
-        cp_subset = root.find("COMPARAM-SUBSET")
-        if cp_subset is not None:
-            comparam_subsets.append(ComparamSubset.from_et(cp_subset, []))
-
-        cp_spec = root.find("COMPARAM-SPEC")
-        if cp_spec is not None:
+        child_elements = list(root)
+        if len(child_elements) != 1:
+            odxraise("Each ODX document must contain exactly one category.")
+
+        category_et = child_elements[0]
+        category_sn = odxrequire(category_et.findtext("SHORT-NAME"))
+        category_tag = category_et.tag
+
+        if category_tag == "DIAG-LAYER-CONTAINER":
+            context = OdxDocContext(model_version,
+                                    (OdxDocFragment(category_sn, DocType.CONTAINER),))
+            self._diag_layer_containers.append(DiagLayerContainer.from_et(category_et, context))
+        elif category_tag == "COMPARAM-SUBSET":
+            context = OdxDocContext(model_version,
+                                    (OdxDocFragment(category_sn, DocType.COMPARAM_SUBSET),))
+            self._comparam_subsets.append(ComparamSubset.from_et(category_et, context))
+        elif category_tag == "COMPARAM-SPEC":
+            # In ODX 2.0 there was only COMPARAM-SPEC. In ODX 2.2 the
+            # content of COMPARAM-SPEC was moved to COMPARAM-SUBSET
+            # and COMPARAM-SPEC became a container for PROT-STACKS and
+            # a PROT-STACK references a list of COMPARAM-SUBSET
+            context = OdxDocContext(model_version,
+                                    (OdxDocFragment(category_sn, DocType.COMPARAM_SPEC),))
             if model_version < Version("2.2"):
-                comparam_subsets.append(ComparamSubset.from_et(cp_spec, []))
-            else:  # odx >= 2.2
-                comparam_specs.append(ComparamSpec.from_et(cp_spec, []))
-
-        self._diag_layer_containers.extend(dlcs)
-        self._comparam_subsets.extend(comparam_subsets)
-        self._comparam_specs.extend(comparam_specs)
+                self._comparam_subsets.append(ComparamSubset.from_et(category_et, context))
+            else:
+                self._comparam_specs.append(ComparamSpec.from_et(category_et, context))
 
     def refresh(self) -> None:
         # Create wrapper objects

odxtools/dataobjectproperty.py

@@ -12,7 +12,8 @@ from .dopbase import DopBase
 from .encodestate import EncodeState
 from .exceptions import EncodeError, odxraise, odxrequire
 from .internalconstr import InternalConstr
-from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkId, OdxLinkRef
 from .odxtypes import AtomicOdxType, BytesTypes, ParameterValue
 from .physicaltype import PhysicalType
 from .snrefcontext import SnRefContext
@@ -20,7 +21,7 @@ from .unit import Unit
 from .utils import dataclass_fields_asdict
 
 
-@dataclass
+@dataclass(kw_only=True)
 class DataObjectProperty(DopBase):
     """This class represents a DATA-OBJECT-PROP.
 
@@ -37,42 +38,40 @@ class DataObjectProperty(DopBase):
     #: The type of the value in the physical world
     physical_type: PhysicalType
 
-    internal_constr: InternalConstr | None
+    internal_constr: InternalConstr | None = None
 
     #: The unit associated with physical values (e.g. 'm/s^2')
-    unit_ref: OdxLinkRef | None
+    unit_ref: OdxLinkRef | None = None
 
-    physical_constr: InternalConstr | None
+    physical_constr: InternalConstr | None = None
 
     @property
     def unit(self) -> Unit | None:
         return self._unit
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element,
-                doc_frags: list[OdxDocFragment]) -> "DataObjectProperty":
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "DataObjectProperty":
         """Reads a DATA-OBJECT-PROP."""
-        kwargs = dataclass_fields_asdict(DopBase.from_et(et_element, doc_frags))
+        kwargs = dataclass_fields_asdict(DopBase.from_et(et_element, context))
 
         diag_coded_type = create_any_diag_coded_type_from_et(
-            odxrequire(et_element.find("DIAG-CODED-TYPE")), doc_frags)
-        physical_type = PhysicalType.from_et(
-            odxrequire(et_element.find("PHYSICAL-TYPE")), doc_frags)
+            odxrequire(et_element.find("DIAG-CODED-TYPE")), context)
+        physical_type = PhysicalType.from_et(odxrequire(et_element.find("PHYSICAL-TYPE")), context)
         compu_method = create_any_compu_method_from_et(
             odxrequire(et_element.find("COMPU-METHOD")),
-            doc_frags,
+            context,
             internal_type=diag_coded_type.base_data_type,
             physical_type=physical_type.base_data_type,
         )
         internal_constr = None
         if (internal_constr_elem := et_element.find("INTERNAL-CONSTR")) is not None:
             internal_constr = InternalConstr.constr_from_et(
-                internal_constr_elem, doc_frags, value_type=diag_coded_type.base_data_type)
-        unit_ref = OdxLinkRef.from_et(et_element.find("UNIT-REF"), doc_frags)
+                internal_constr_elem, context, value_type=diag_coded_type.base_data_type)
+        unit_ref = OdxLinkRef.from_et(et_element.find("UNIT-REF"), context)
         physical_constr = None
         if (physical_constr_elem := et_element.find("PHYS-CONSTR")) is not None:
             physical_constr = InternalConstr.constr_from_et(
-                physical_constr_elem, doc_frags, value_type=physical_type.base_data_type)
+                physical_constr_elem, context, value_type=physical_type.base_data_type)
 
         return DataObjectProperty(
             compu_method=compu_method,
@@ -118,7 +117,7 @@ class DataObjectProperty(DopBase):
                 f"The value {repr(physical_value)} of type {type(physical_value).__name__}"
                 f" is not a valid.")
 
-        if not isinstance(physical_value, int | float | str | BytesTypes):
+        if not isinstance(physical_value, (int, float, str, BytesTypes)):
             odxraise(f"Invalid type '{type(physical_value).__name__}' for physical value. "
                      f"(Expect atomic type!)")
         internal_value = self.compu_method.convert_physical_to_internal(physical_value)

odxtools/description.py

@@ -1,22 +1,22 @@
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from typing import Optional
 from xml.etree import ElementTree
 
 from .exceptions import odxrequire
 from .externaldoc import ExternalDoc
-from .odxlink import OdxDocFragment
+from .odxdoccontext import OdxDocContext
 
 
-@dataclass
+@dataclass(kw_only=True)
 class Description:
     text: str
-    external_docs: list[ExternalDoc]
+    external_docs: list[ExternalDoc] = field(default_factory=list)
 
-    text_identifier: str | None
+    text_identifier: str | None = None
 
     @staticmethod
     def from_et(et_element: ElementTree.Element | None,
-                doc_frags: list[OdxDocFragment]) -> Optional["Description"]:
+                context: OdxDocContext) -> Optional["Description"]:
         if et_element is None:
             return None
 
@@ -35,7 +35,7 @@ class Description:
 
         external_docs = \
             [
-                odxrequire(ExternalDoc.from_et(ed, doc_frags)) for ed in et_element.iterfind("EXTERNAL-DOCS/EXTERNAL-DOC")
+                odxrequire(ExternalDoc.from_et(ed, context)) for ed in et_element.iterfind("EXTERNAL-DOCS/EXTERNAL-DOC")
             ]
 
         text_identifier = et_element.attrib.get("TI")

odxtools/determinenumberofitems.py

@@ -5,17 +5,18 @@ from xml.etree import ElementTree
 
 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 .snrefcontext import SnRefContext
 
 
-@dataclass
+@dataclass(kw_only=True)
 class DetermineNumberOfItems:
     """
     The object that determines the number of items of dynamic fields
     """
     byte_position: int
-    bit_position: int | None
+    bit_position: int | None = None
     dop_ref: OdxLinkRef
 
     @property
@@ -24,11 +25,11 @@ class DetermineNumberOfItems:
 
     @staticmethod
     def from_et(et_element: ElementTree.Element,
-                doc_frags: list[OdxDocFragment]) -> "DetermineNumberOfItems":
+                context: OdxDocContext) -> "DetermineNumberOfItems":
         byte_position = int(odxrequire(et_element.findtext("BYTE-POSITION")))
         bit_position_str = et_element.findtext("BIT-POSITION")
         bit_position = int(bit_position_str) if bit_position_str is not None else None
-        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 DetermineNumberOfItems(
             byte_position=byte_position,