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

odxtools/compumethods/createanycompumethod.py

@@ -2,7 +2,7 @@
 from xml.etree import ElementTree
 
 from ..exceptions import odxraise, odxrequire
-from ..odxlink import OdxDocFragment
+from ..odxdoccontext import OdxDocContext
 from ..odxtypes import DataType
 from .compucodecompumethod import CompuCodeCompuMethod
 from .compumethod import CompuMethod
@@ -15,38 +15,38 @@ from .tabintpcompumethod import TabIntpCompuMethod
 from .texttablecompumethod import TexttableCompuMethod
 
 
-def create_any_compu_method_from_et(et_element: ElementTree.Element,
-                                    doc_frags: list[OdxDocFragment], *, internal_type: DataType,
+def create_any_compu_method_from_et(et_element: ElementTree.Element, context: OdxDocContext, *,
+                                    internal_type: DataType,
                                     physical_type: DataType) -> CompuMethod:
     compu_category = odxrequire(et_element.findtext("CATEGORY"))
 
     if compu_category == "IDENTICAL":
         return IdenticalCompuMethod.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)
     elif compu_category == "LINEAR":
         return LinearCompuMethod.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)
     elif compu_category == "SCALE-LINEAR":
         return ScaleLinearCompuMethod.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)
     elif compu_category == "RAT-FUNC":
         return RatFuncCompuMethod.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)
     elif compu_category == "SCALE-RAT-FUNC":
         return ScaleRatFuncCompuMethod.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)
     elif compu_category == "TEXTTABLE":
         return TexttableCompuMethod.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)
     elif compu_category == "COMPUCODE":
         return CompuCodeCompuMethod.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)
     elif compu_category == "TAB-INTP":
         return TabIntpCompuMethod.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)
 
     # TODO: Implement all categories (never instantiate the CompuMethod base class!)
     odxraise(f"Warning: Computation category {compu_category} is not implemented!")
 
     return IdenticalCompuMethod.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)

odxtools/compumethods/identicalcompumethod.py

@@ -3,13 +3,13 @@ from dataclasses import dataclass
 from xml.etree import ElementTree
 
 from ..exceptions import odxassert
-from ..odxlink import OdxDocFragment
+from ..odxdoccontext import OdxDocContext
 from ..odxtypes import AtomicOdxType, DataType
 from ..utils import dataclass_fields_asdict
 from .compumethod import CompuMethod
 
 
-@dataclass
+@dataclass(kw_only=True)
 class IdenticalCompuMethod(CompuMethod):
     """Identical compu methods just pass through the internal value.
 
@@ -17,11 +17,11 @@ class IdenticalCompuMethod(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) -> "IdenticalCompuMethod":
         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)
 
         odxassert(

odxtools/compumethods/limit.py

@@ -4,16 +4,16 @@ from typing import Optional, overload
 from xml.etree import ElementTree
 
 from ..exceptions import odxraise
-from ..odxlink import OdxDocFragment
+from ..odxdoccontext import OdxDocContext
 from ..odxtypes import AtomicOdxType, DataType, compare_odx_values
 from .intervaltype import IntervalType
 
 
-@dataclass
+@dataclass(kw_only=True)
 class Limit:
-    value_raw: str | None
-    value_type: DataType | None
-    interval_type: IntervalType | None
+    value_raw: str | None = None
+    value_type: DataType | None = None
+    interval_type: IntervalType | None = None
 
     @property
     def value(self) -> AtomicOdxType | None:
@@ -21,18 +21,18 @@ class Limit:
 
     @staticmethod
     @overload
-    def limit_from_et(et_element: ElementTree.Element, doc_frags: list[OdxDocFragment],
+    def limit_from_et(et_element: ElementTree.Element, context: OdxDocContext,
                       value_type: DataType | None) -> "Limit":
         ...
 
     @staticmethod
     @overload
-    def limit_from_et(et_element: None, doc_frags: list[OdxDocFragment],
+    def limit_from_et(et_element: None, context: OdxDocContext,
                       value_type: DataType | None) -> None:
         ...
 
     @staticmethod
-    def limit_from_et(et_element: ElementTree.Element | None, doc_frags: list[OdxDocFragment],
+    def limit_from_et(et_element: ElementTree.Element | None, context: OdxDocContext,
                       value_type: DataType | None) -> Optional["Limit"]:
 
         if et_element is None:

odxtools/compumethods/linearcompumethod.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 .linearsegment import LinearSegment
 
 
-@dataclass
+@dataclass(kw_only=True)
 class LinearCompuMethod(CompuMethod):
     """A compu method which does linear interpoation
 
@@ -30,11 +30,11 @@ class LinearCompuMethod(CompuMethod):
         return self._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) -> "LinearCompuMethod":
         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 LinearCompuMethod(**kwargs)

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