odxtools 5.3.1__py3-none-any.whl → 6.0.1__py3-none-any.whl

odxtools/communicationparameterref.py

@@ -111,6 +111,7 @@ class CommunicationParameterRef:
                 f"'{self.short_name}' are not specified "
                 f"correctly.",
                 OdxWarning,
+                stacklevel=1,
             )
             return None
 
@@ -122,6 +123,7 @@ class CommunicationParameterRef:
                 f"Communication parameter '{self.short_name}' "
                 f"does not specify a '{subparam_name}' sub-parameter.",
                 OdxWarning,
+                stacklevel=1,
             )
             return None
 
@@ -134,9 +136,10 @@ class CommunicationParameterRef:
         return result
 
     @property
-    def short_name(self):
+    def short_name(self) -> str:
         if self.comparam:
             return self.comparam.short_name
-        # ODXLINK IDs allow dots and hyphens, but python identifiers do not.
-        # This should not happen anyway in a correct PDX
+
+        # ODXLINK IDs allow dots and hyphens, but short names do not.
+        # (This should not happen anyway in a correct PDX...)
         return self.id_ref.ref_id.replace(".", "__").replace("-", "_")

odxtools/companydocinfo.py

@@ -54,7 +54,7 @@ class CompanyDocInfo:
 
         return result
 
-    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase):
+    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
         self._company_data = odxlinks.resolve(self.company_data_ref, CompanyData)
 
         self._team_member: Optional[TeamMember] = None
@@ -64,6 +64,6 @@ class CompanyDocInfo:
         for sdg in self.sdgs:
             sdg._resolve_odxlinks(odxlinks)
 
-    def _resolve_snrefs(self, diag_layer: "DiagLayer"):
+    def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
         for sdg in self.sdgs:
             sdg._resolve_snrefs(diag_layer)

odxtools/companyrevisioninfo.py

@@ -36,7 +36,7 @@ class CompanyRevisionInfo:
     def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
         return {}
 
-    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase):
+    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
         self._company_data = odxlinks.resolve(self.company_data_ref, CompanyData)
 
     def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:

odxtools/comparamsubset.py

@@ -87,8 +87,8 @@ class ComparamSubset(IdentifiableElement):
         for comparam in self.comparams:
             odxlinks.update(comparam._build_odxlinks())
 
-        for comparam in self.complex_comparams:
-            odxlinks.update(comparam._build_odxlinks())
+        for ccomparam in self.complex_comparams:
+            odxlinks.update(ccomparam._build_odxlinks())
 
         if self.unit_spec:
             odxlinks.update(self.unit_spec._build_odxlinks())
@@ -112,8 +112,8 @@ class ComparamSubset(IdentifiableElement):
         for comparam in self.comparams:
             comparam._resolve_odxlinks(odxlinks)
 
-        for comparam in self.complex_comparams:
-            comparam._resolve_odxlinks(odxlinks)
+        for ccomparam in self.complex_comparams:
+            ccomparam._resolve_odxlinks(odxlinks)
 
         if self.unit_spec:
             self.unit_spec._resolve_odxlinks(odxlinks)
@@ -135,8 +135,8 @@ class ComparamSubset(IdentifiableElement):
         for comparam in self.comparams:
             comparam._resolve_snrefs(diag_layer)
 
-        for comparam in self.complex_comparams:
-            comparam._resolve_snrefs(diag_layer)
+        for ccomparam in self.complex_comparams:
+            ccomparam._resolve_snrefs(diag_layer)
 
         if self.unit_spec:
             self.unit_spec._resolve_snrefs(diag_layer)

odxtools/complexcomparam.py

@@ -32,7 +32,7 @@ class ComplexComparam(BaseComparam):
 
     @property
     def allow_multiple_values(self) -> bool:
-        return self.allow_multiple_values_raw == True
+        return self.allow_multiple_values_raw is True
 
     @staticmethod
     def from_et(et_element: ElementTree.Element,

odxtools/compumethods/compumethod.py

@@ -1,9 +1,9 @@
 # SPDX-License-Identifier: MIT
 import abc
 from dataclasses import dataclass
-from typing import Literal, Union
+from typing import Literal
 
-from ..odxtypes import DataType
+from ..odxtypes import AtomicOdxType, DataType
 
 CompuMethodCategory = Literal[
     "IDENTICAL",
@@ -24,17 +24,14 @@ class CompuMethod(abc.ABC):
     def category(self) -> CompuMethodCategory:
         pass
 
-    def convert_physical_to_internal(self, physical_value):
+    def convert_physical_to_internal(self, physical_value: AtomicOdxType) -> AtomicOdxType:
         raise NotImplementedError()
 
-    def convert_internal_to_physical(self, internal_value) -> Union[int, float, str]:
+    def convert_internal_to_physical(self, internal_value: AtomicOdxType) -> AtomicOdxType:
         raise NotImplementedError()
 
-    def is_valid_physical_value(self, physical_value):
+    def is_valid_physical_value(self, physical_value: AtomicOdxType) -> bool:
         raise NotImplementedError()
 
-    def is_valid_internal_value(self, internal_value):
+    def is_valid_internal_value(self, internal_value: AtomicOdxType) -> bool:
         raise NotImplementedError()
-
-    def get_valid_physical_values(self):
-        return None

odxtools/compumethods/createanycompumethod.py

@@ -19,12 +19,12 @@ from .texttablecompumethod import TexttableCompuMethod
 
 def _parse_compu_scale_to_linear_compu_method(
     *,
-    scale_element,
+    scale_element: ElementTree.Element,
     internal_type: DataType,
     physical_type: DataType,
-    is_scale_linear=False,
-    **kwargs,
-):
+    is_scale_linear: bool = False,
+    **kwargs: Any,
+) -> LinearCompuMethod:
     odxassert(physical_type in [
         DataType.A_FLOAT32,
         DataType.A_FLOAT64,
@@ -47,18 +47,20 @@ def _parse_compu_scale_to_linear_compu_method(
     kwargs["internal_type"] = internal_type
     kwargs["physical_type"] = physical_type
 
-    coeffs = scale_element.find("COMPU-RATIONAL-COEFFS")
+    coeffs = odxrequire(scale_element.find("COMPU-RATIONAL-COEFFS"))
     nums = coeffs.iterfind("COMPU-NUMERATOR/V")
 
-    offset = computation_python_type(next(nums).text)
+    offset = computation_python_type(odxrequire(next(nums).text))
     factor_el = next(nums, None)
-    factor = computation_python_type(factor_el.text if factor_el is not None else "0")
+    factor = computation_python_type(odxrequire(factor_el.text) if factor_el is not None else "0")
     denominator = 1.0
     if (string := coeffs.findtext("COMPU-DENOMINATOR/V")) is not None:
         denominator = float(string)
         if denominator == 0:
-            warnings.warn("CompuMethod: A denominator of zero will lead to divisions by zero.",
-                          OdxWarning)
+            warnings.warn(
+                "CompuMethod: A denominator of zero will lead to divisions by zero.",
+                OdxWarning,
+                stacklevel=1)
     # Read lower limit
     internal_lower_limit = Limit.from_et(
         scale_element.find("LOWER-LIMIT"),

odxtools/compumethods/identicalcompumethod.py

@@ -1,6 +1,7 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
 
+from ..odxtypes import AtomicOdxType
 from .compumethod import CompuMethod, CompuMethodCategory
 
 
@@ -11,14 +12,14 @@ class IdenticalCompuMethod(CompuMethod):
     def category(self) -> CompuMethodCategory:
         return "IDENTICAL"
 
-    def convert_physical_to_internal(self, physical_value):
+    def convert_physical_to_internal(self, physical_value: AtomicOdxType) -> AtomicOdxType:
         return physical_value
 
-    def convert_internal_to_physical(self, internal_value):
+    def convert_internal_to_physical(self, internal_value: AtomicOdxType) -> AtomicOdxType:
         return internal_value
 
-    def is_valid_physical_value(self, physical_value):
+    def is_valid_physical_value(self, physical_value: AtomicOdxType) -> bool:
         return self.physical_type.isinstance(physical_value)
 
-    def is_valid_internal_value(self, internal_value):
+    def is_valid_internal_value(self, internal_value: AtomicOdxType) -> bool:
         return self.internal_type.isinstance(internal_value)

odxtools/compumethods/limit.py

@@ -1,11 +1,11 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
 from enum import Enum
-from typing import Optional, Union
+from typing import Optional
 from xml.etree import ElementTree
 
 from ..exceptions import odxassert, odxraise, odxrequire
-from ..odxtypes import DataType
+from ..odxtypes import AtomicOdxType, DataType
 
 
 class IntervalType(Enum):
@@ -16,7 +16,7 @@ class IntervalType(Enum):
 
 @dataclass
 class Limit:
-    value: Union[str, int, float, bytes]
+    value: AtomicOdxType
     interval_type: IntervalType = IntervalType.CLOSED
 
     def __post_init__(self) -> None:
@@ -53,7 +53,7 @@ class Limit:
         else:
             return Limit(internal_type.from_string(odxrequire(et_element.text)), interval_type)
 
-    def complies_to_upper(self, value):
+    def complies_to_upper(self, value: AtomicOdxType) -> bool:
         """Checks if the value is in the range w.r.t. the upper limit.
 
         * If the interval type is closed, return `value <= limit.value`.
@@ -61,13 +61,13 @@ class Limit:
         * If the interval type is infinite, return `True`.
         """
         if self.interval_type == IntervalType.CLOSED:
-            return value <= self.value
+            return value <= self.value  # type: ignore[operator]
         elif self.interval_type == IntervalType.OPEN:
-            return value < self.value
+            return value < self.value  # type: ignore[operator]
         elif self.interval_type == IntervalType.INFINITE:
             return True
 
-    def complies_to_lower(self, value):
+    def complies_to_lower(self, value: AtomicOdxType) -> bool:
         """Checks if the value is in the range w.r.t. the lower limit.
 
         * If the interval type is closed, return `limit.value <= value`.
@@ -75,8 +75,8 @@ class Limit:
         * If the interval type is infinite, return `True`.
         """
         if self.interval_type == IntervalType.CLOSED:
-            return self.value <= value
+            return self.value <= value  # type: ignore[operator]
         elif self.interval_type == IntervalType.OPEN:
-            return self.value < value
+            return self.value < value  # type: ignore[operator]
         elif self.interval_type == IntervalType.INFINITE:
             return True

odxtools/compumethods/linearcompumethod.py

@@ -1,9 +1,9 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import Union
+from typing import cast
 
-from ..exceptions import odxassert
-from ..odxtypes import DataType
+from ..exceptions import DecodeError, EncodeError, odxassert
+from ..odxtypes import AtomicOdxType, DataType
 from .compumethod import CompuMethod, CompuMethodCategory
 from .limit import IntervalType, Limit
 
@@ -73,20 +73,20 @@ class LinearCompuMethod(CompuMethod):
         return "LINEAR"
 
     @property
-    def physical_lower_limit(self):
+    def physical_lower_limit(self) -> Limit:
         return self._physical_lower_limit
 
     @property
-    def physical_upper_limit(self):
+    def physical_upper_limit(self) -> Limit:
         return self._physical_upper_limit
 
-    def __compute_physical_limits(self):
+    def __compute_physical_limits(self) -> None:
         """Computes the physical limits and stores them in the properties
         self._physical_lower_limit and self._physical_upper_limit.
         This method is only called during the initialization of a LinearCompuMethod.
         """
 
-        def convert_to_limit_to_physical(limit: Limit, is_upper_limit: bool):
+        def convert_to_limit_to_physical(limit: Limit, is_upper_limit: bool) -> Limit:
             """Helper method
 
             Parameters:
@@ -127,10 +127,14 @@ class LinearCompuMethod(CompuMethod):
         if self.physical_type == DataType.A_UINT32:
             # If the data type is unsigned, the physical lower limit should be at least 0.
             if (self._physical_lower_limit.interval_type == IntervalType.INFINITE or
-                    self._physical_lower_limit.value < 0):
+                    cast(float, self._physical_lower_limit.value) < 0):
                 self._physical_lower_limit = Limit(value=0, interval_type=IntervalType.CLOSED)
 
-    def _convert_internal_to_physical(self, internal_value):
+    def _convert_internal_to_physical(self, internal_value: AtomicOdxType) -> AtomicOdxType:
+        if not isinstance(internal_value, (int, float)):
+            raise DecodeError("The type of internal values of linear compumethods must "
+                              "either int or float")
+
         if self.denominator is None:
             result = self.offset + self.factor * internal_value
         else:
@@ -143,11 +147,15 @@ class LinearCompuMethod(CompuMethod):
             result = round(result)
         return self.physical_type.make_from(result)
 
-    def convert_internal_to_physical(self, internal_value) -> Union[int, float]:
+    def convert_internal_to_physical(self, internal_value: AtomicOdxType) -> AtomicOdxType:
         odxassert(self.is_valid_internal_value(internal_value))
         return self._convert_internal_to_physical(internal_value)
 
-    def convert_physical_to_internal(self, physical_value):
+    def convert_physical_to_internal(self, physical_value: AtomicOdxType) -> AtomicOdxType:
+        if not isinstance(physical_value, (int, float)):
+            raise EncodeError("The type of physical values of linear compumethods must "
+                              "either int or float")
+
         odxassert(
             self.is_valid_physical_value(physical_value),
             f"physical value {physical_value} of type {type(physical_value)} "
@@ -165,12 +173,12 @@ class LinearCompuMethod(CompuMethod):
             result = round(result)
         return self.internal_type.make_from(result)
 
-    def is_valid_physical_value(self, physical_value):
+    def is_valid_physical_value(self, physical_value: AtomicOdxType) -> bool:
         # Do type checks
         expected_type = self.physical_type.as_python_type()
-        if expected_type == float and type(physical_value) not in [int, float]:
+        if expected_type == float and not isinstance(physical_value, (int, float)):
             return False
-        elif expected_type != float and type(physical_value) != expected_type:
+        elif expected_type != float and not isinstance(physical_value, expected_type):
             return False
 
         # Compare to the limits
@@ -180,11 +188,11 @@ class LinearCompuMethod(CompuMethod):
             return False
         return True
 
-    def is_valid_internal_value(self, internal_value):
+    def is_valid_internal_value(self, internal_value: AtomicOdxType) -> bool:
         expected_type = self.internal_type.as_python_type()
-        if expected_type == float and type(internal_value) not in [int, float]:
+        if expected_type == float and not isinstance(internal_value, (int, float)):
             return False
-        elif expected_type != float and type(internal_value) != expected_type:
+        elif expected_type != float and not isinstance(internal_value, expected_type):
             return False
 
         if not self.internal_lower_limit.complies_to_lower(internal_value):

odxtools/compumethods/scalelinearcompumethod.py

@@ -3,6 +3,7 @@ from dataclasses import dataclass
 from typing import List
 
 from ..exceptions import odxassert
+from ..odxtypes import AtomicOdxType
 from .compumethod import CompuMethod, CompuMethodCategory
 from .linearcompumethod import LinearCompuMethod
 
@@ -15,24 +16,24 @@ class ScaleLinearCompuMethod(CompuMethod):
     def category(self) -> CompuMethodCategory:
         return "SCALE-LINEAR"
 
-    def convert_physical_to_internal(self, physical_value):
+    def convert_physical_to_internal(self, physical_value: AtomicOdxType) -> AtomicOdxType:
         odxassert(
             self.is_valid_physical_value(physical_value),
-            f"cannot convert the invalid physical value {physical_value} "
+            f"cannot convert the invalid physical value {physical_value!r} "
             f"of type {type(physical_value)}")
         lin_method = next(
             scale for scale in self.linear_methods if scale.is_valid_physical_value(physical_value))
         return lin_method.convert_physical_to_internal(physical_value)
 
-    def convert_internal_to_physical(self, internal_value):
+    def convert_internal_to_physical(self, internal_value: AtomicOdxType) -> AtomicOdxType:
         lin_method = next(
             scale for scale in self.linear_methods if scale.is_valid_internal_value(internal_value))
         return lin_method.convert_internal_to_physical(internal_value)
 
-    def is_valid_physical_value(self, physical_value):
+    def is_valid_physical_value(self, physical_value: AtomicOdxType) -> bool:
         return any(
             True for scale in self.linear_methods if scale.is_valid_physical_value(physical_value))
 
-    def is_valid_internal_value(self, internal_value):
+    def is_valid_internal_value(self, internal_value: AtomicOdxType) -> bool:
         return any(
             True for scale in self.linear_methods if scale.is_valid_internal_value(internal_value))

odxtools/compumethods/tabintpcompumethod.py

@@ -3,7 +3,7 @@ from dataclasses import dataclass
 from typing import List, Tuple, Union
 
 from ..exceptions import DecodeError, EncodeError, odxassert, odxraise
-from ..odxtypes import DataType
+from ..odxtypes import AtomicOdxType, DataType
 from .compumethod import CompuMethod, CompuMethodCategory
 from .limit import IntervalType, Limit
 
@@ -115,34 +115,55 @@ class TabIntpCompuMethod(CompuMethod):
 
         return None
 
-    def convert_physical_to_internal(self, physical_value: Union[int, float]) -> Union[int, float]:
+    def convert_physical_to_internal(self, physical_value: AtomicOdxType) -> AtomicOdxType:
+        if not isinstance(physical_value, (int, float)):
+            raise EncodeError("The type of values of tab-intp compumethods must "
+                              "either int or float")
+
         reference_points = list(zip(self.physical_points, self.internal_points))
-        result = self._piecewise_linear_interpolate(physical_value, reference_points)
+        odxassert(
+            isinstance(physical_value, (int, float)),
+            "Only integers and floats can be piecewise linearly interpolated")
+        result = self._piecewise_linear_interpolate(
+            physical_value,  # type: ignore[arg-type]
+            reference_points)
 
         if result is None:
-            raise EncodeError(f"Internal value {physical_value} must be inside the range"
+            raise EncodeError(f"Internal value {physical_value!r} must be inside the range"
                               f" [{min(self.physical_points)}, {max(self.physical_points)}]")
         res = self.internal_type.make_from(result)
         if not isinstance(res, (int, float)):
             odxraise()
         return res
 
-    def convert_internal_to_physical(self, internal_value: Union[int, float]) -> Union[int, float]:
+    def convert_internal_to_physical(self, internal_value: AtomicOdxType) -> AtomicOdxType:
+        if not isinstance(internal_value, (int, float)):
+            raise EncodeError("The internal type of values of tab-intp compumethods must "
+                              "either int or float")
+
         reference_points = list(zip(self.internal_points, self.physical_points))
-        result = self._piecewise_linear_interpolate(internal_value, reference_points)
+        result = self._piecewise_linear_interpolate(
+            internal_value,  # type: ignore[arg-type]
+            reference_points)
 
         if result is None:
-            raise DecodeError(f"Internal value {internal_value} must be inside the range"
+            raise DecodeError(f"Internal value {internal_value!r} must be inside the range"
                               f" [{min(self.internal_points)}, {max(self.internal_points)}]")
         res = self.physical_type.make_from(result)
         if not isinstance(res, (int, float)):
             odxraise()
         return res
 
-    def is_valid_physical_value(self, physical_value: Union[int, float]) -> bool:
+    def is_valid_physical_value(self, physical_value: AtomicOdxType) -> bool:
+        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: Union[int, float]) -> bool:
+    def is_valid_internal_value(self, internal_value: AtomicOdxType) -> bool:
+        if not isinstance(internal_value, (int, float)):
+            return False
+
         return min(self.internal_points) <= internal_value and internal_value <= max(
             self.internal_points)

odxtools/compumethods/texttablecompumethod.py

@@ -3,7 +3,7 @@ from dataclasses import dataclass
 from typing import List, Optional
 
 from ..exceptions import DecodeError, EncodeError, odxassert
-from ..odxtypes import DataType
+from ..odxtypes import AtomicOdxType, DataType
 from .compumethod import CompuMethod, CompuMethodCategory
 from .compuscale import CompuScale
 
@@ -28,25 +28,26 @@ class TexttableCompuMethod(CompuMethod):
     def category(self) -> CompuMethodCategory:
         return "TEXTTABLE"
 
-    def _get_scales(self):
+    def get_scales(self) -> List[CompuScale]:
         scales = list(self.internal_to_phys)
         if self.compu_default_value:
             # Default is last, since it's a fallback
             scales.append(self.compu_default_value)
         return scales
 
-    def convert_physical_to_internal(self, physical_value):
-        scale: CompuScale = next(
-            filter(lambda scale: scale.compu_const == physical_value, self._get_scales()), None)
-        if scale is not None:
-            res = (
-                scale.compu_inverse_value
-                if scale.compu_inverse_value is not None else scale.lower_limit.value)
-            odxassert(self.internal_type.isinstance(res))
-            return res
-        raise EncodeError(f"Texttable compu method could not encode '{physical_value}'.")
+    def convert_physical_to_internal(self, physical_value: AtomicOdxType) -> AtomicOdxType:
+        matching_scales = [x for x in self.get_scales() if x.compu_const == physical_value]
+        for scale in matching_scales:
+            if scale.compu_inverse_value is not None:
+                return scale.compu_inverse_value
+            elif scale.lower_limit is not None:
+                return scale.lower_limit.value
+            elif scale.upper_limit is not None:
+                return scale.upper_limit.value
 
-    def __is_internal_in_scale(self, internal_value, scale: CompuScale):
+        raise EncodeError(f"Texttable compu method could not encode '{physical_value!r}'.")
+
+    def __is_internal_in_scale(self, internal_value: AtomicOdxType, scale: CompuScale) -> bool:
         if scale == self.compu_default_value:
             return True
         if scale.lower_limit is not None and not scale.lower_limit.complies_to_lower(
@@ -60,23 +61,20 @@ class TexttableCompuMethod(CompuMethod):
         # value complies to the defined limits
         return True
 
-    def convert_internal_to_physical(self, internal_value):
+    def convert_internal_to_physical(self, internal_value: AtomicOdxType) -> AtomicOdxType:
         scale = next(
             filter(
                 lambda scale: self.__is_internal_in_scale(internal_value, scale),
-                self._get_scales(),
+                self.get_scales(),
             ), None)
-        if scale is None:
+        if scale is None or scale.compu_const is None:
             raise DecodeError(
-                f"Texttable compu method could not decode {internal_value} to string.")
+                f"Texttable compu method could not decode {internal_value!r} to string.")
         return scale.compu_const
 
-    def is_valid_physical_value(self, physical_value):
-        return physical_value in self.get_valid_physical_values()
+    def is_valid_physical_value(self, physical_value: AtomicOdxType) -> bool:
+        return any(x.compu_const == physical_value for x in self.get_scales())
 
-    def is_valid_internal_value(self, internal_value):
+    def is_valid_internal_value(self, internal_value: AtomicOdxType) -> bool:
         return any(
-            self.__is_internal_in_scale(internal_value, scale) for scale in self._get_scales())
-
-    def get_valid_physical_values(self):
-        return [x.compu_const for x in self._get_scales()]
+            self.__is_internal_in_scale(internal_value, scale) for scale in self.get_scales())

odxtools/database.py

@@ -1,7 +1,7 @@
 # SPDX-License-Identifier: MIT
 from itertools import chain
 from pathlib import Path
-from typing import List, Optional
+from typing import List, Optional, Tuple
 from xml.etree import ElementTree
 from zipfile import ZipFile
 
@@ -13,7 +13,7 @@ from .nameditemlist import NamedItemList, short_name_as_key
 from .odxlink import OdxLinkDatabase
 
 
-def version(v: str):
+def version(v: str) -> Tuple[int, ...]:
     return tuple(map(int, (v.split("."))))
 
 
@@ -135,13 +135,13 @@ class Database:
         return self._diag_layers
 
     @property
-    def diag_layer_containers(self):
+    def diag_layer_containers(self) -> NamedItemList[DiagLayerContainer]:
         return self._diag_layer_containers
 
     @diag_layer_containers.setter
-    def diag_layer_containers(self, value):
+    def diag_layer_containers(self, value: NamedItemList[DiagLayerContainer]) -> None:
         self._diag_layer_containers = value
 
     @property
-    def comparam_subsets(self):
+    def comparam_subsets(self) -> NamedItemList[ComparamSubset]:
         return self._comparam_subsets