odxtools 8.1.0__py3-none-any.whl → 8.2.0__py3-none-any.whl

odxtools/diaglayers/hierarchyelementraw.py

@@ -22,7 +22,13 @@ class HierarchyElementRaw(DiagLayerRaw):
     @staticmethod
     def from_et(et_element: ElementTree.Element,
                 doc_frags: List[OdxDocFragment]) -> "HierarchyElementRaw":
-        kwargs = dataclass_fields_asdict(DiagLayerRaw.from_et(et_element, doc_frags))
+        # objects contained by diagnostic layers exibit an additional
+        # document fragment for the diag layer, so we use the document
+        # fragments of the odx id of the diag layer for IDs of
+        # contained objects.
+        dlr = DiagLayerRaw.from_et(et_element, doc_frags)
+        kwargs = dataclass_fields_asdict(dlr)
+        doc_frags = dlr.odx_id.doc_fragments
 
         comparam_refs = [
             ComparamInstance.from_et(el, doc_frags)

odxtools/diaglayers/protocolraw.py

@@ -37,7 +37,13 @@ class ProtocolRaw(HierarchyElementRaw):
 
     @staticmethod
     def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "ProtocolRaw":
-        kwargs = dataclass_fields_asdict(HierarchyElementRaw.from_et(et_element, doc_frags))
+        # objects contained by diagnostic layers exibit an additional
+        # document fragment for the diag layer, so we use the document
+        # fragments of the odx id of the diag layer for IDs of
+        # contained objects.
+        her = HierarchyElementRaw.from_et(et_element, doc_frags)
+        kwargs = dataclass_fields_asdict(her)
+        doc_frags = her.odx_id.doc_fragments
 
         comparam_spec_ref = OdxLinkRef.from_et(
             odxrequire(et_element.find("COMPARAM-SPEC-REF")), doc_frags)

odxtools/dtcdop.py

@@ -178,6 +178,8 @@ class DtcDop(DopBase):
     def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
         odxlinks = super()._build_odxlinks()
 
+        odxlinks.update(self.compu_method._build_odxlinks())
+
         for dtc_proxy in self.dtcs_raw:
             if isinstance(dtc_proxy, DiagnosticTroubleCode):
                 odxlinks.update(dtc_proxy._build_odxlinks())
@@ -187,6 +189,8 @@ class DtcDop(DopBase):
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
         super()._resolve_odxlinks(odxlinks)
 
+        self.compu_method._resolve_odxlinks(odxlinks)
+
         self._dtcs = NamedItemList[DiagnosticTroubleCode]()
         for dtc_proxy in self.dtcs_raw:
             if isinstance(dtc_proxy, DiagnosticTroubleCode):
@@ -202,6 +206,8 @@ class DtcDop(DopBase):
     def _resolve_snrefs(self, context: SnRefContext) -> None:
         super()._resolve_snrefs(context)
 
+        self.compu_method._resolve_snrefs(context)
+
         for dtc_proxy in self.dtcs_raw:
             if isinstance(dtc_proxy, DiagnosticTroubleCode):
                 dtc_proxy._resolve_snrefs(context)

odxtools/environmentdatadescription.py

@@ -11,6 +11,7 @@ from .dtcdop import DtcDop
 from .encodestate import EncodeState
 from .environmentdata import EnvironmentData
 from .exceptions import odxraise, odxrequire
+from .nameditemlist import NamedItemList
 from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef
 from .odxtypes import ParameterValue, ParameterValueDict
 from .parameters.parameter import Parameter
@@ -35,7 +36,7 @@ class EnvironmentDataDescription(ComplexDop):
     # in ODX 2.0.0, ENV-DATAS seems to be a mandatory
     # sub-element of ENV-DATA-DESC, in ODX 2.2 it is not
     # present
-    env_datas: List[EnvironmentData]
+    env_datas: NamedItemList[EnvironmentData]
     env_data_refs: List[OdxLinkRef]
 
     @property
@@ -62,16 +63,20 @@ class EnvironmentDataDescription(ComplexDop):
         param_snpathref = None
         if (param_snpathref_elem := et_element.find("PARAM-SNPATHREF")) is not None:
             param_snpathref = odxrequire(param_snpathref_elem.get("SHORT-NAME-PATH"))
+
+        # ODX 2.0 mandates ENV-DATA-DESC to contain a list of
+        # ENV-DATAS and no ENV-DATA-REFS while for ODX 2.2 the
+        # situation is reversed. This means that we will create one
+        # empty and one non-empty list here. (Which is which depends
+        # on the version of the standard used by the file.)
         env_data_refs = [
             odxrequire(OdxLinkRef.from_et(env_data_ref, doc_frags))
             for env_data_ref in et_element.iterfind("ENV-DATA-REFS/ENV-DATA-REF")
         ]
-
-        # ODX 2.0.0 says ENV-DATA-DESC could contain a list of ENV-DATAS
-        env_datas = [
+        env_datas = NamedItemList([
             EnvironmentData.from_et(env_data_elem, doc_frags)
             for env_data_elem in et_element.iterfind("ENV-DATAS/ENV-DATA")
-        ]
+        ])
 
         return EnvironmentDataDescription(
             param_snref=param_snref,
@@ -93,7 +98,7 @@ class EnvironmentDataDescription(ComplexDop):
         # ODX 2.0 specifies environment data objects here, ODX 2.2
         # uses references
         if self.env_data_refs:
-            self.env_datas = [odxlinks.resolve(x) for x in self.env_data_refs]
+            self.env_datas = NamedItemList([odxlinks.resolve(x) for x in self.env_data_refs])
         else:
             for ed in self.env_datas:
                 ed._resolve_odxlinks(odxlinks)

odxtools/multiplexer.py

@@ -12,6 +12,7 @@ from .exceptions import DecodeError, EncodeError, odxassert, odxraise, odxrequir
 from .multiplexercase import MultiplexerCase
 from .multiplexerdefaultcase import MultiplexerDefaultCase
 from .multiplexerswitchkey import MultiplexerSwitchKey
+from .nameditemlist import NamedItemList
 from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
 from .odxtypes import AtomicOdxType, ParameterValue, odxstr_to_bool
 from .snrefcontext import SnRefContext
@@ -30,7 +31,7 @@ class Multiplexer(ComplexDop):
     byte_position: int
     switch_key: MultiplexerSwitchKey
     default_case: Optional[MultiplexerDefaultCase]
-    cases: List[MultiplexerCase]
+    cases: NamedItemList[MultiplexerCase]
     is_visible_raw: Optional[bool]
 
     @staticmethod
@@ -48,9 +49,8 @@ class Multiplexer(ComplexDop):
         if (dc_elem := et_element.find("DEFAULT-CASE")) is not None:
             default_case = MultiplexerDefaultCase.from_et(dc_elem, doc_frags)
 
-        cases = []
-        if (cases_elem := et_element.find("CASES")) is not None:
-            cases = [MultiplexerCase.from_et(el, doc_frags) for el in cases_elem.iterfind("CASE")]
+        cases = NamedItemList(
+            [MultiplexerCase.from_et(el, doc_frags) for el in et_element.iterfind("CASES/CASE")])
 
         is_visible_raw = odxstr_to_bool(et_element.get("IS-VISIBLE"))
 

odxtools/multiplexercase.py

@@ -15,7 +15,7 @@ from .utils import dataclass_fields_asdict
 
 @dataclass
 class MultiplexerCase(NamedElement):
-    """This class represents a Case which represents multiple options in a Multiplexer."""
+    """This class represents a case which represents a range of keys of a multiplexer."""
 
     structure_ref: Optional[OdxLinkRef]
     structure_snref: Optional[str]

odxtools/odxtypes.py

@@ -241,3 +241,17 @@ class DataType(Enum):
             return True
         else:
             return False
+
+    def __str__(self) -> str:
+        if self == DataType.A_INT32:
+            return "int"
+        elif self == DataType.A_UINT32:
+            return "uint"
+        elif self in (DataType.A_FLOAT32, DataType.A_FLOAT64):
+            return "float"
+        elif self == DataType.A_BYTEFIELD:
+            return "bytefield"
+        elif self in (DataType.A_UNICODE2STRING, DataType.A_ASCIISTRING, DataType.A_UTF8STRING):
+            return "string"
+        else:
+            return f"<unknown type '{self.value}'>"

odxtools/parameterinfo.py

@@ -3,9 +3,15 @@ import textwrap
 from io import StringIO
 from typing import Iterable
 
+from .compumethods.compucodecompumethod import CompuCodeCompuMethod
 from .compumethods.identicalcompumethod import IdenticalCompuMethod
 from .compumethods.limit import IntervalType
 from .compumethods.linearcompumethod import LinearCompuMethod
+from .compumethods.linearsegment import LinearSegment
+from .compumethods.ratfunccompumethod import RatFuncCompuMethod
+from .compumethods.ratfuncsegment import RatFuncSegment
+from .compumethods.scalelinearcompumethod import ScaleLinearCompuMethod
+from .compumethods.scaleratfunccompumethod import ScaleRatFuncCompuMethod
 from .compumethods.texttablecompumethod import TexttableCompuMethod
 from .dataobjectproperty import DataObjectProperty
 from .dtcdop import DtcDop
@@ -13,19 +19,55 @@ from .dynamiclengthfield import DynamicLengthField
 from .endofpdufield import EndOfPduField
 from .exceptions import odxrequire
 from .multiplexer import Multiplexer
-from .odxtypes import DataType
 from .parameters.codedconstparameter import CodedConstParameter
 from .parameters.matchingrequestparameter import MatchingRequestParameter
 from .parameters.nrcconstparameter import NrcConstParameter
 from .parameters.parameter import Parameter
 from .parameters.parameterwithdop import ParameterWithDOP
 from .parameters.reservedparameter import ReservedParameter
+from .parameters.systemparameter import SystemParameter
 from .parameters.tablekeyparameter import TableKeyParameter
 from .parameters.tablestructparameter import TableStructParameter
 from .paramlengthinfotype import ParamLengthInfoType
 from .staticfield import StaticField
 
 
+def _get_linear_segment_info(segment: LinearSegment) -> str:
+    ll = segment.physical_lower_limit
+    ul = segment.physical_upper_limit
+    if ll is None or ll.interval_type == IntervalType.INFINITE:
+        ll_str = "(-inf"
+    else:
+        ll_delim = '(' if ll.interval_type == IntervalType.OPEN else '['
+        ll_str = f"{ll_delim}{ll._value!r}"
+
+        if ul is None or ul.interval_type == IntervalType.INFINITE:
+            ul_str = "inf)"
+        else:
+            ul_delim = ')' if ul.interval_type == IntervalType.OPEN else ']'
+            ul_str = f"{ul._value!r}{ul_delim}"
+
+    return f"{ll_str}, {ul_str}"
+
+
+def _get_rat_func_segment_info(segment: RatFuncSegment) -> str:
+    ll = segment.lower_limit
+    ul = segment.upper_limit
+    if ll is None or ll.interval_type == IntervalType.INFINITE:
+        ll_str = "(-inf"
+    else:
+        ll_delim = '(' if ll.interval_type == IntervalType.OPEN else '['
+        ll_str = f"{ll_delim}{ll._value!r}"
+
+        if ul is None or ul.interval_type == IntervalType.INFINITE:
+            ul_str = "inf)"
+        else:
+            ul_delim = ')' if ul.interval_type == IntervalType.OPEN else ']'
+            ul_str = f"{ul._value!r}{ul_delim}"
+
+    return f"{ll_str}, {ul_str}"
+
+
 def parameter_info(param_list: Iterable[Parameter], quoted_names: bool = False) -> str:
     q = "'" if quoted_names else ""
     of = StringIO()
@@ -42,6 +84,11 @@ def parameter_info(param_list: Iterable[Parameter], quoted_names: bool = False)
         elif isinstance(param, ReservedParameter):
             of.write(f"{q}{param.short_name}{q}: <reserved>\n")
             continue
+        elif isinstance(param, SystemParameter):
+            of.write(
+                f"{q}{param.short_name}{q}: <system; kind = \"{param.sysparam}\">; required = {param.is_required}\n"
+            )
+            continue
         elif isinstance(param, TableKeyParameter):
             of.write(
                 f"{q}{param.short_name}{q}: <optional> table key; table = '{param.table.short_name}'; choices:\n"
@@ -69,7 +116,10 @@ def parameter_info(param_list: Iterable[Parameter], quoted_names: bool = False)
             continue
 
         dop = param.dop
-        if isinstance(dop, EndOfPduField):
+        if dop is None:
+            of.write("{q}{param.short_name}{q}: <no DOP>\n")
+            continue
+        elif isinstance(dop, EndOfPduField):
             of.write(f"{q}{param.short_name}{q}: list({{\n")
             of.write(textwrap.indent(parameter_info(dop.structure.parameters, True), "  "))
             of.write(f"}})\n")
@@ -112,89 +162,95 @@ def parameter_info(param_list: Iterable[Parameter], quoted_names: bool = False)
                     of.write(textwrap.indent(parameter_info(struc.parameters, True), "    "))
                 of.write(f"   }})\n")
             continue
+        elif isinstance(dop, DataObjectProperty):
+            # a "simple" DOP
+            if (cm := dop.compu_method) is None:
+                of.write(f"{q}{param.short_name}{q}: <no compu method>\n")
+                continue
 
-        of.write(f"{q}{param.short_name}{q}")
+            if isinstance(cm, TexttableCompuMethod):
+                of.write(f"{q}{param.short_name}{q}: enum; choices:\n")
+                for scale in odxrequire(cm.compu_internal_to_phys).compu_scales:
+                    val_str = ""
+                    if scale.lower_limit is not None:
+                        val_str = f"({repr(scale.lower_limit.value)})"
 
-        if dop is None:
-            of.write(": <no DOP>\n")
-            continue
-        elif not isinstance(dop, DataObjectProperty):
-            of.write(f": <unhandled DOP '{type(dop).__name__}'>\n")
-            continue
+                    if scale.compu_const is None:
+                        of.write(f"  <ERROR in ODX data: no value specified>\n")
+                    else:
+                        vt = scale.compu_const.vt
+                        v = scale.compu_const.v
+                        if vt is not None:
+                            of.write(f"  \"{vt}\" {val_str}\n")
+                        else:
+                            of.write(f"  {v}\n")
 
-        if (cm := dop.compu_method) is None:
-            of.write(": <no compu method>\n")
-            continue
+            elif isinstance(cm, IdenticalCompuMethod):
+                of.write(f"{q}{param.short_name}{q}: {dop.physical_type.base_data_type}\n")
 
-        if isinstance(cm, TexttableCompuMethod):
-            of.write(f": enum; choices:\n")
-            for scale in odxrequire(cm.compu_internal_to_phys).compu_scales:
-                val_str = ""
-                if scale.lower_limit is not None:
-                    val_str = f"({repr(scale.lower_limit.value)})"
+            elif isinstance(cm, ScaleLinearCompuMethod):
+                of.write(f"{q}{param.short_name}{q}: {dop.physical_type.base_data_type}")
+                seg_list = [_get_linear_segment_info(x) for x in cm.segments]
+                of.write(f"; ranges = {{ {', '.join(seg_list)} }}")
 
-                if scale.compu_const is None:
-                    of.write(f"  <ERROR in ODX data: no value specified>\n")
+                unit = dop.unit
+                unit_str = unit.display_name if unit is not None else None
+                if unit_str is not None:
+                    of.write(f"; unit: {unit_str}")
+
+                of.write("\n")
+
+            elif isinstance(cm, LinearCompuMethod):
+                of.write(f"{q}{param.short_name}{q}: {dop.physical_type.base_data_type}")
+                of.write(f"; range: {_get_linear_segment_info(cm.segment)}")
+
+                unit = dop.unit
+                unit_str = unit.display_name if unit is not None else None
+                if unit_str is not None:
+                    of.write(f"; unit: {unit_str}")
+
+                of.write("\n")
+
+            elif isinstance(cm, ScaleRatFuncCompuMethod):
+                of.write(f"{q}{param.short_name}{q}: {dop.physical_type.base_data_type}")
+                if cm._phys_to_int_segments is None:
+                    of.write("<NOT ENCODABLE>")
                 else:
-                    vt = scale.compu_const.vt
-                    v = scale.compu_const.v
-                    if vt is not None:
-                        of.write(f"  \"{vt}\" {val_str}\n")
-                    else:
-                        of.write(f"  {v}\n")
-
-        elif isinstance(cm, IdenticalCompuMethod):
-            bdt = dop.physical_type.base_data_type
-            if bdt in (DataType.A_UTF8STRING, DataType.A_UNICODE2STRING, DataType.A_ASCIISTRING):
-                of.write(f": str")
-            elif bdt == DataType.A_BYTEFIELD:
-                of.write(f": bytes")
-            elif bdt.name.startswith("A_FLOAT"):
-                of.write(f": float")
-            elif bdt.name.startswith("A_UINT"):
-                of.write(f": uint")
-            elif bdt.name.startswith("A_INT"):
-                of.write(f": int")
-            else:
-                of.write(f": <unknown type {{ bdt.name }}>")
-
-            of.write("\n")
-
-        elif isinstance(cm, LinearCompuMethod):
-            bdt = dop.physical_type.base_data_type
-            if bdt in (DataType.A_UTF8STRING, DataType.A_UNICODE2STRING, DataType.A_ASCIISTRING):
-                of.write(f": str")
-            elif bdt in (DataType.A_BYTEFIELD,):
-                of.write(f": bytes")
-            elif bdt.name.startswith("A_FLOAT"):
-                of.write(f": float")
-            elif bdt.name.startswith("A_UINT"):
-                of.write(f": uint")
-            elif bdt.name.startswith("A_INT"):
-                of.write(f": int")
-            else:
-                of.write(f": <unknown type>")
+                    seg_list = [_get_rat_func_segment_info(x) for x in cm._phys_to_int_segments]
+                    of.write(f"; ranges = {{ {', '.join(seg_list)} }}")
 
-            ll = cm.segment.physical_lower_limit
-            ul = cm.segment.physical_upper_limit
-            if ll is None or ll.interval_type == IntervalType.INFINITE:
-                ll_str = "(-inf"
-            else:
-                ll_delim = '(' if ll.interval_type == IntervalType.OPEN else '['
-                ll_str = f"{ll_delim}{ll._value!r}"
+                    unit = dop.unit
+                    unit_str = unit.display_name if unit is not None else None
+                    if unit_str is not None:
+                        of.write(f"; unit: {unit_str}")
 
-            if ul is None or ul.interval_type == IntervalType.INFINITE:
-                ul_str = "inf)"
-            else:
-                ul_delim = ')' if ul.interval_type == IntervalType.OPEN else ']'
-                ul_str = f"{ul._value!r}{ul_delim}"
-            of.write(f"; range: {ll_str}, {ul_str}")
+                    of.write("\n")
+
+            elif isinstance(cm, RatFuncCompuMethod):
+                of.write(f"{q}{param.short_name}{q}: {dop.physical_type.base_data_type}")
+                if cm._phys_to_int_segment is None:
+                    of.write("<NOT ENCODABLE>")
+                else:
+                    of.write(f"; range: {_get_rat_func_segment_info(cm._phys_to_int_segment)}")
+
+                    unit = dop.unit
+                    unit_str = unit.display_name if unit is not None else None
+                    if unit_str is not None:
+                        of.write(f"; unit: {unit_str}")
 
-            unit = dop.unit
-            unit_str = unit.display_name if unit is not None else None
-            if unit_str is not None:
-                of.write(f"; unit: {unit_str}")
+                of.write("\n")
 
-            of.write("\n")
+            elif isinstance(cm, CompuCodeCompuMethod):
+                of.write(f"{q}{param.short_name}{q}: {dop.physical_type.base_data_type}")
+                of.write(f"; <programmatic translation>")
+
+                of.write("\n")
+
+            else:
+                of.write(
+                    f"{q}{param.short_name}{q}: unknown compu method {type(dop.compu_method).__name__}\n"
+                )
+        else:
+            of.write(f"{q}{param.short_name}{q}: <unhandled DOP '{type(dop).__name__}'>\n")
 
     return of.getvalue()

odxtools/parameters/systemparameter.py

@@ -1,19 +1,29 @@
 # SPDX-License-Identifier: MIT
+import getpass
 from dataclasses import dataclass
+from datetime import datetime
 from typing import List, Optional
 from xml.etree import ElementTree
 
 from typing_extensions import override
 
-from ..decodestate import DecodeState
 from ..encodestate import EncodeState
-from ..exceptions import odxrequire
+from ..exceptions import odxraise, odxrequire
 from ..odxlink import OdxDocFragment
 from ..odxtypes import ParameterValue
 from ..utils import dataclass_fields_asdict
 from .parameter import ParameterType
 from .parameterwithdop import ParameterWithDOP
 
+# The SYSTEM parameter types mandated by the ODX 2.2 standard. Users
+# are free to specify additional types, but these must be handled
+# (cf. table 5 in section 7.3.5.4 of the ASAM ODX 2.2 specification
+# document.)
+PREDEFINED_SYSPARAM_VALUES = [
+    "TIMESTAMP", "SECOND", "MINUTE", "HOUR", "TIMEZONE", "DAY", "WEEK", "MONTH", "YEAR", "CENTURY",
+    "TESTERID", "USERID"
+]
+
 
 @dataclass
 class SystemParameter(ParameterWithDOP):
@@ -38,18 +48,51 @@ class SystemParameter(ParameterWithDOP):
     @property
     @override
     def is_required(self) -> bool:
-        raise NotImplementedError("SystemParameter.is_required is not implemented yet.")
+        # if a SYSTEM parameter is not specified explicitly, its value
+        # can be determined from the operating system if it is type is
+        # predefined
+        return self.sysparam not in PREDEFINED_SYSPARAM_VALUES
 
     @property
     @override
     def is_settable(self) -> bool:
-        raise NotImplementedError("SystemParameter.is_settable is not implemented yet.")
+        return True
 
     @override
     def _encode_positioned_into_pdu(self, physical_value: Optional[ParameterValue],
                                     encode_state: EncodeState) -> None:
-        raise NotImplementedError("Encoding a SystemParameter is not implemented yet.")
+        if physical_value is None:
+            # determine the value to be encoded automatically
+            now = datetime.now()
+            if self.sysparam == "TIMESTAMP":
+                physical_value = round(now.timestamp() * 1000).to_bytes(8, "big")
+            elif self.sysparam == "SECOND":
+                physical_value = now.second
+            elif self.sysparam == "MINUTE":
+                physical_value = now.minute
+            elif self.sysparam == "HOUR":
+                physical_value = now.hour
+            elif self.sysparam == "TIMEZONE":
+                if (utc_offset := now.astimezone().utcoffset()) is not None:
+                    physical_value = utc_offset.seconds // 60
+                else:
+                    physical_value = 0
+            elif self.sysparam == "DAY":
+                physical_value = now.day
+            elif self.sysparam == "WEEK":
+                physical_value = now.isocalendar()[1]
+            elif self.sysparam == "MONTH":
+                physical_value = now.month
+            elif self.sysparam == "YEAR":
+                physical_value = now.year
+            elif self.sysparam == "CENTURY":
+                physical_value = now.year // 100
+            elif self.sysparam == "TESTERID":
+                physical_value = "odxtools".encode("latin1")
+            elif self.sysparam == "USERID":
+                physical_value = getpass.getuser().encode("latin1")
+            else:
+                odxraise(f"Unknown system parameter type '{self.sysparam}'")
+                physical_value = 0
 
-    @override
-    def _decode_positioned_from_pdu(self, decode_state: DecodeState) -> ParameterValue:
-        raise NotImplementedError("Decoding SystemParameter is not implemented yet.")
+        self.dop.encode_into_pdu(physical_value, encode_state=encode_state)

odxtools/standardlengthtype.py

@@ -88,7 +88,10 @@ class StandardLengthType(DiagCodedType):
         else:
             sz = (odxrequire(self.get_static_bit_length()) + 7) // 8
 
-        return self.bit_mask.to_bytes(sz, endianness)
+        max_value = (1 << (sz * 8)) - 1
+        bit_mask = self.bit_mask & max_value
+
+        return bit_mask.to_bytes(sz, endianness)
 
     def __apply_mask(self, internal_value: AtomicOdxType) -> AtomicOdxType:
         if self.bit_mask is None:

odxtools/unitspec.py

@@ -1,6 +1,6 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import Any, Dict, List, Union
+from typing import Any, Dict, List
 from xml.etree import ElementTree
 
 from .nameditemlist import NamedItemList
@@ -25,9 +25,9 @@ class UnitSpec:
     """
 
     # TODO (?): Why are there type errors...
-    unit_groups: Union[NamedItemList[UnitGroup], List[UnitGroup]]
-    units: Union[NamedItemList[Unit], List[Unit]]
-    physical_dimensions: Union[NamedItemList[PhysicalDimension], List[PhysicalDimension]]
+    unit_groups: NamedItemList[UnitGroup]
+    units: NamedItemList[Unit]
+    physical_dimensions: NamedItemList[PhysicalDimension]
     sdgs: List[SpecialDataGroup]
 
     def __post_init__(self) -> None:
@@ -38,14 +38,15 @@ class UnitSpec:
     @staticmethod
     def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "UnitSpec":
 
-        unit_groups = [
+        unit_groups = NamedItemList([
             UnitGroup.from_et(el, doc_frags) for el in et_element.iterfind("UNIT-GROUPS/UNIT-GROUP")
-        ]
-        units = [Unit.from_et(el, doc_frags) for el in et_element.iterfind("UNITS/UNIT")]
-        physical_dimensions = [
+        ])
+        units = NamedItemList(
+            [Unit.from_et(el, doc_frags) for el in et_element.iterfind("UNITS/UNIT")])
+        physical_dimensions = NamedItemList([
             PhysicalDimension.from_et(el, doc_frags)
             for el in et_element.iterfind("PHYSICAL-DIMENSIONS/PHYSICAL-DIMENSION")
-        ]
+        ])
         sdgs = [
             SpecialDataGroup.from_et(sdge, doc_frags) for sdge in et_element.iterfind("SDGS/SDG")
         ]

odxtools/version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '8.1.0'
-__version_tuple__ = version_tuple = (8, 1, 0)
+__version__ = version = '8.2.0'
+__version_tuple__ = version_tuple = (8, 2, 0)

{odxtools-8.1.0.dist-info → odxtools-8.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: odxtools
-Version: 8.1.0
+Version: 8.2.0
 Summary: Utilities to work with the ODX standard for automotive diagnostics
 Author-email: Katrin Bauer <katrin.bauer@mbition.io>, Andreas Lauser <andreas.lauser@mbition.io>, Ayoub Kaanich <kayoub5@live.com>
 Maintainer-email: Andreas Lauser <andreas.lauser@mbition.io>, Ayoub Kaanich <kayoub5@live.com>