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

odxtools/compumethods/createanycompumethod.py

@@ -1,9 +1,8 @@
 # SPDX-License-Identifier: MIT
-from typing import List
 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
@@ -16,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

@@ -1,16 +1,15 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import List
 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.
 
@@ -18,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

@@ -1,39 +1,39 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import List, Optional, overload
+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: Optional[str]
-    value_type: Optional[DataType]
-    interval_type: Optional[IntervalType]
+    value_raw: str | None = None
+    value_type: DataType | None = None
+    interval_type: IntervalType | None = None
 
     @property
-    def value(self) -> Optional[AtomicOdxType]:
+    def value(self) -> AtomicOdxType | None:
         return self._value
 
     @staticmethod
     @overload
-    def limit_from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment],
-                      value_type: Optional[DataType]) -> "Limit":
+    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],
-                      value_type: Optional[DataType]) -> None:
+    def limit_from_et(et_element: None, context: OdxDocContext,
+                      value_type: DataType | None) -> None:
         ...
 
     @staticmethod
-    def limit_from_et(et_element: Optional[ElementTree.Element], doc_frags: List[OdxDocFragment],
-                      value_type: Optional[DataType]) -> Optional["Limit"]:
+    def limit_from_et(et_element: ElementTree.Element | None, context: OdxDocContext,
+                      value_type: DataType | None) -> Optional["Limit"]:
 
         if et_element is None:
             return None
@@ -50,7 +50,7 @@ class Limit:
         return Limit(value_raw=value_raw, interval_type=interval_type, value_type=value_type)
 
     def __post_init__(self) -> None:
-        self._value: Optional[AtomicOdxType] = None
+        self._value: AtomicOdxType | None = None
 
         if self.value_type is not None:
             self.set_value_type(self.value_type)

odxtools/compumethods/linearcompumethod.py

@@ -1,10 +1,10 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import List, 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 ..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

@@ -1,6 +1,5 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import Optional, Union
 
 from ..exceptions import odxraise, odxrequire
 from ..odxtypes import AtomicOdxType, DataType
@@ -8,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.
 
@@ -24,20 +23,20 @@ class LinearSegment:
     offset: float
     factor: float
     denominator: float
-    internal_lower_limit: Optional[Limit]
-    internal_upper_limit: Optional[Limit]
+    internal_lower_limit: Limit | None = None
+    internal_upper_limit: Limit | None = None
 
-    inverse_value: Union[int, float]  # value used as inverse if factor is 0
+    inverse_value: int | float  # value used as inverse if factor is 0
 
     internal_type: DataType
     physical_type: DataType
 
     @property
-    def physical_lower_limit(self) -> Optional[Limit]:
+    def physical_lower_limit(self) -> Limit | None:
         return self._physical_lower_limit
 
     @property
-    def physical_upper_limit(self) -> Optional[Limit]:
+    def physical_upper_limit(self) -> Limit | None:
         return self._physical_upper_limit
 
     @staticmethod
@@ -52,7 +51,7 @@ class LinearSegment:
         if len(coeffs.denominators) > 0:
             denominator = coeffs.denominators[0]
 
-        inverse_value: Union[int, float] = 0
+        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)):
@@ -75,7 +74,7 @@ class LinearSegment:
     def __post_init__(self) -> None:
         self.__compute_physical_limits()
 
-    def convert_internal_to_physical(self, internal_value: AtomicOdxType) -> Union[float, int]:
+    def convert_internal_to_physical(self, internal_value: AtomicOdxType) -> float | int:
         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 +89,7 @@ class LinearSegment:
 
         return result
 
-    def convert_physical_to_internal(self, physical_value: AtomicOdxType) -> Union[float, int]:
+    def convert_physical_to_internal(self, physical_value: AtomicOdxType) -> float | int:
         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__})")
@@ -115,7 +114,7 @@ class LinearSegment:
         This method is called by `__post_init__()`.
         """
 
-        def convert_internal_to_physical_limit(internal_limit: Optional[Limit]) -> Optional[Limit]:
+        def convert_internal_to_physical_limit(internal_limit: Limit | None) -> Limit | None:
             """Helper method to convert a single internal limit
             """
             if internal_limit is None or internal_limit.value_raw is None:

odxtools/compumethods/ratfunccompumethod.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 ..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
 
@@ -30,15 +30,15 @@ class RatFuncCompuMethod(CompuMethod):
         return self._int_to_phys_segment
 
     @property
-    def phys_to_int_segment(self) -> Optional[RatFuncSegment]:
+    def phys_to_int_segment(self) -> RatFuncSegment | None:
         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,6 +1,5 @@
 # SPDX-License-Identifier: MIT
-from dataclasses import dataclass
-from typing import List, Optional, Union
+from dataclasses import dataclass, field
 
 from ..exceptions import odxraise, odxrequire
 from ..odxtypes import AtomicOdxType, DataType
@@ -8,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[Union[int, float]]
-    denominator_coeffs: List[Union[int, float]]
+    numerator_coeffs: list[int | float] = field(default_factory=list)
+    denominator_coeffs: list[int | float] = field(default_factory=list)
 
-    lower_limit: Optional[Limit]
-    upper_limit: Optional[Limit]
+    lower_limit: Limit | None = None
+    upper_limit: Limit | None = None
 
     @staticmethod
     def from_compu_scale(scale: CompuScale, value_type: DataType) -> "RatFuncSegment":
@@ -39,7 +38,7 @@ class RatFuncSegment:
             upper_limit=upper_limit,
             value_type=scale.range_type)
 
-    def convert(self, value: AtomicOdxType) -> Union[float, int]:
+    def convert(self, value: AtomicOdxType) -> float | int:
         if not isinstance(value, (int, float)):
             odxraise(f"Internal values of linear compumethods must "
                      f"either be int or float (is: {type(value).__name__})")

odxtools/compumethods/scalelinearcompumethod.py

@@ -1,10 +1,10 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import List, Union, 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 ..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.
 
@@ -21,21 +21,21 @@ class ScaleLinearCompuMethod(CompuMethod):
     """
 
     @property
-    def segments(self) -> List[LinearSegment]:
+    def segments(self) -> list[LinearSegment]:
         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)
 
     def __post_init__(self) -> None:
-        self._segments: List[LinearSegment] = []
+        self._segments: list[LinearSegment] = []
 
         odxassert(self.category == CompuCategory.SCALE_LINEAR,
                   "ScaleLinearCompuMethod must exibit SCALE-LINEAR category")
@@ -111,7 +111,7 @@ class ScaleLinearCompuMethod(CompuMethod):
                 self._is_invertible = False
                 break
 
-    def convert_physical_to_internal(self, physical_value: AtomicOdxType) -> Union[float, int]:
+    def convert_physical_to_internal(self, physical_value: AtomicOdxType) -> float | int:
         if not self._is_invertible:
             odxraise(
                 f"Trying to encode value {physical_value!r} using a non-invertible "
@@ -128,7 +128,7 @@ class ScaleLinearCompuMethod(CompuMethod):
 
         return seg.convert_physical_to_internal(physical_value)
 
-    def convert_internal_to_physical(self, internal_value: AtomicOdxType) -> Union[float, int]:
+    def convert_internal_to_physical(self, internal_value: AtomicOdxType) -> float | int:
         applicable_segments = [
             seg for seg in self._segments if seg.internal_applies(internal_value)
         ]

odxtools/compumethods/scaleratfunccompumethod.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 ..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
 
@@ -20,19 +20,19 @@ class ScaleRatFuncCompuMethod(CompuMethod):
     """
 
     @property
-    def int_to_phys_segments(self) -> List[RatFuncSegment]:
+    def int_to_phys_segments(self) -> list[RatFuncSegment]:
         return self._int_to_phys_segments
 
     @property
-    def phys_to_int_segments(self) -> Optional[List[RatFuncSegment]]:
+    def phys_to_int_segments(self) -> list[RatFuncSegment] | None:
         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

@@ -1,10 +1,9 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import List, Union
 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
@@ -13,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.
@@ -37,11 +36,11 @@ class TabIntpCompuMethod(CompuMethod):
     """
 
     @property
-    def internal_points(self) -> List[Union[float, int]]:
+    def internal_points(self) -> list[float | int]:
         return self._internal_points
 
     @property
-    def physical_points(self) -> List[Union[float, int]]:
+    def physical_points(self) -> list[float | int]:
         return self._physical_points
 
     @property
@@ -61,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)
@@ -74,8 +73,8 @@ class TabIntpCompuMethod(CompuMethod):
         odxassert(self.category == CompuCategory.TAB_INTP,
                   "TabIntpCompuMethod must exibit TAB-INTP category")
 
-        self._internal_points: List[Union[int, float]] = []
-        self._physical_points: List[Union[int, float]] = []
+        self._internal_points: list[int | float] = []
+        self._physical_points: list[int | float] = []
         for scale in odxrequire(self.compu_internal_to_phys).compu_scales:
             internal_point = odxrequire(scale.lower_limit).value
             physical_point = odxrequire(scale.compu_const).value
@@ -130,10 +129,8 @@ class TabIntpCompuMethod(CompuMethod):
             ], "Physical data type of TAB-INTP compumethod must be one of"
             " [A_INT32, A_UINT32, A_FLOAT32, A_FLOAT64]")
 
-    def __piecewise_linear_interpolate(self, x: Union[int, float],
-                                       range_samples: List[Union[int, float]],
-                                       domain_samples: List[Union[int,
-                                                                  float]]) -> Union[float, None]:
+    def __piecewise_linear_interpolate(self, x: int | float, range_samples: list[int | float],
+                                       domain_samples: list[int | float]) -> float | None:
         for i in range(0, len(range_samples) - 1):
             if (x0 := range_samples[i]) <= x and x <= (x1 := range_samples[i + 1]):
                 y0 = domain_samples[i]

odxtools/compumethods/texttablecompumethod.py

@@ -1,10 +1,10 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import List, cast
+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)
@@ -95,7 +95,7 @@ class TexttableCompuMethod(CompuMethod):
         scales = []
         if (citp := self.compu_internal_to_phys) is not None:
             scales = citp.compu_scales
-        matching_scales: List[CompuScale] = [x for x in scales if x.applies(internal_value)]
+        matching_scales: list[CompuScale] = [x for x in scales if x.applies(internal_value)]
 
         if len(matching_scales) == 0:
             if self._compu_physical_default_value is None:

odxtools/createanycomparam.py

@@ -1,17 +1,15 @@
-from typing import List, Union
 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]) -> Union[Comparam, ComplexComparam]:
+def create_any_comparam_from_et(et_element: ElementTree.Element,
+                                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

@@ -1,5 +1,4 @@
 # SPDX-License-Identifier: MIT
-from typing import List
 from xml.etree import ElementTree
 
 from .diagcodedtype import DiagCodedType
@@ -7,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)