odxtools 9.4.1__py3-none-any.whl → 9.6.0__py3-none-any.whl

odxtools/minmaxlengthtype.py

@@ -12,7 +12,7 @@ from .encodestate import EncodeState
 from .encoding import get_string_encoding
 from .exceptions import DecodeError, EncodeError, odxassert, odxraise, odxrequire
 from .odxlink import OdxDocFragment
-from .odxtypes import AtomicOdxType, DataType
+from .odxtypes import AtomicOdxType, BytesTypes, DataType
 from .utils import dataclass_fields_asdict
 
 
@@ -24,8 +24,8 @@ class Termination(Enum):
 
 @dataclass
 class MinMaxLengthType(DiagCodedType):
-    min_length: int
     max_length: Optional[int]
+    min_length: int
     termination: Termination
 
     @property
@@ -38,12 +38,12 @@ class MinMaxLengthType(DiagCodedType):
                 doc_frags: List[OdxDocFragment]) -> "MinMaxLengthType":
         kwargs = dataclass_fields_asdict(DiagCodedType.from_et(et_element, doc_frags))
 
-        min_length = int(odxrequire(et_element.findtext("MIN-LENGTH")))
         max_length = None
         if et_element.find("MAX-LENGTH") is not None:
             max_length = int(odxrequire(et_element.findtext("MAX-LENGTH")))
+        min_length = int(odxrequire(et_element.findtext("MIN-LENGTH")))
 
-        termination_str = odxrequire(et_element.get("TERMINATION"))
+        termination_str = odxrequire(et_element.attrib.get("TERMINATION"))
         try:
             termination = Termination(termination_str)
         except ValueError:
@@ -51,7 +51,7 @@ class MinMaxLengthType(DiagCodedType):
             odxraise(f"Encountered unknown termination type '{termination_str}'")
 
         return MinMaxLengthType(
-            min_length=min_length, max_length=max_length, termination=termination, **kwargs)
+            max_length=max_length, min_length=min_length, termination=termination, **kwargs)
 
     def __post_init__(self) -> None:
         odxassert(self.max_length is None or self.min_length <= self.max_length)
@@ -83,7 +83,7 @@ class MinMaxLengthType(DiagCodedType):
     @override
     def encode_into_pdu(self, internal_value: AtomicOdxType, encode_state: EncodeState) -> None:
 
-        if not isinstance(internal_value, (bytes, str, bytearray)):
+        if not isinstance(internal_value, (str, BytesTypes)):
             odxraise("MinMaxLengthType is currently only implemented for strings and byte arrays",
                      EncodeError)
 

odxtools/multiplexer.py

@@ -34,12 +34,15 @@ class Multiplexer(ComplexDop):
     cases: NamedItemList[MultiplexerCase]
     is_visible_raw: Optional[bool]
 
+    @property
+    def is_visible(self) -> bool:
+        return self.is_visible_raw is True
+
     @staticmethod
     @override
     def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "Multiplexer":
         """Reads a Multiplexer from Diag Layer."""
-        base_obj = ComplexDop.from_et(et_element, doc_frags)
-        kwargs = dataclass_fields_asdict(base_obj)
+        kwargs = dataclass_fields_asdict(ComplexDop.from_et(et_element, doc_frags))
 
         byte_position = int(et_element.findtext("BYTE-POSITION", "0"))
         switch_key = MultiplexerSwitchKey.from_et(
@@ -55,16 +58,45 @@ class Multiplexer(ComplexDop):
         is_visible_raw = odxstr_to_bool(et_element.get("IS-VISIBLE"))
 
         return Multiplexer(
-            is_visible_raw=is_visible_raw,
             byte_position=byte_position,
             switch_key=switch_key,
             default_case=default_case,
             cases=cases,
+            is_visible_raw=is_visible_raw,
             **kwargs)
 
-    @property
-    def is_visible(self) -> bool:
-        return self.is_visible_raw is True
+    @override
+    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+        odxlinks = super()._build_odxlinks()
+
+        odxlinks.update(self.switch_key._build_odxlinks())
+        if self.default_case is not None:
+            odxlinks.update(self.default_case._build_odxlinks())
+
+        return odxlinks
+
+    @override
+    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
+        super()._resolve_odxlinks(odxlinks)
+
+        self.switch_key._resolve_odxlinks(odxlinks)
+        if self.default_case is not None:
+            self.default_case._resolve_odxlinks(odxlinks)
+
+        for mux_case in self.cases:
+            mux_case._mux_case_resolve_odxlinks(
+                odxlinks, key_physical_type=self.switch_key.dop.physical_type.base_data_type)
+
+    @override
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
+        super()._resolve_snrefs(context)
+
+        self.switch_key._resolve_snrefs(context)
+        if self.default_case is not None:
+            self.default_case._resolve_snrefs(context)
+
+        for mux_case in self.cases:
+            mux_case._resolve_snrefs(context)
 
     def _get_case_limits(self, case: MultiplexerCase) -> Tuple[AtomicOdxType, AtomicOdxType]:
         key_type = self.switch_key.dop.physical_type.base_data_type
@@ -203,36 +235,3 @@ class Multiplexer(ComplexDop):
         decode_state.origin_byte_position = orig_origin
 
         return result
-
-    @override
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
-        odxlinks = super()._build_odxlinks()
-
-        odxlinks.update(self.switch_key._build_odxlinks())
-        if self.default_case is not None:
-            odxlinks.update(self.default_case._build_odxlinks())
-
-        return odxlinks
-
-    @override
-    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
-        super()._resolve_odxlinks(odxlinks)
-
-        self.switch_key._resolve_odxlinks(odxlinks)
-        if self.default_case is not None:
-            self.default_case._resolve_odxlinks(odxlinks)
-
-        for mux_case in self.cases:
-            mux_case._mux_case_resolve_odxlinks(
-                odxlinks, key_physical_type=self.switch_key.dop.physical_type.base_data_type)
-
-    @override
-    def _resolve_snrefs(self, context: SnRefContext) -> None:
-        super()._resolve_snrefs(context)
-
-        self.switch_key._resolve_snrefs(context)
-        if self.default_case is not None:
-            self.default_case._resolve_snrefs(context)
-
-        for mux_case in self.cases:
-            mux_case._resolve_snrefs(context)

odxtools/multiplexercase.py

@@ -22,8 +22,9 @@ class MultiplexerCase(NamedElement):
     lower_limit: Limit
     upper_limit: Limit
 
-    def __post_init__(self) -> None:
-        self._structure: Optional[Structure]
+    @property
+    def structure(self) -> Optional[Structure]:
+        return self._structure
 
     @staticmethod
     def from_et(et_element: ElementTree.Element,
@@ -77,7 +78,3 @@ class MultiplexerCase(NamedElement):
     def applies(self, value: AtomicOdxType) -> bool:
         return self.lower_limit.complies_to_lower(value) \
             and self.upper_limit.complies_to_upper(value)
-
-    @property
-    def structure(self) -> Optional[Structure]:
-        return self._structure

odxtools/multiplexerdefaultcase.py

@@ -17,8 +17,9 @@ class MultiplexerDefaultCase(NamedElement):
     structure_ref: Optional[OdxLinkRef]
     structure_snref: Optional[str]
 
-    def __post_init__(self) -> None:
-        self._structure: Optional[Structure]
+    @property
+    def structure(self) -> Optional[Structure]:
+        return self._structure
 
     @staticmethod
     def from_et(et_element: ElementTree.Element,
@@ -46,7 +47,3 @@ class MultiplexerDefaultCase(NamedElement):
         if self.structure_snref:
             ddds = odxrequire(context.diag_layer).diag_data_dictionary_spec
             self._structure = resolve_snref(self.structure_snref, ddds.structures, Structure)
-
-    @property
-    def structure(self) -> Optional[Structure]:
-        return self._structure

odxtools/multiplexerswitchkey.py

@@ -18,6 +18,10 @@ class MultiplexerSwitchKey:
     bit_position: Optional[int]
     dop_ref: OdxLinkRef
 
+    @property
+    def dop(self) -> DataObjectProperty:
+        return self._dop
+
     @staticmethod
     def from_et(et_element: ElementTree.Element,
                 doc_frags: List[OdxDocFragment]) -> "MultiplexerSwitchKey":
@@ -40,7 +44,3 @@ class MultiplexerSwitchKey:
 
     def _resolve_snrefs(self, context: SnRefContext) -> None:
         pass
-
-    @property
-    def dop(self) -> DataObjectProperty:
-        return self._dop

odxtools/negoutputparam.py

@@ -1,6 +1,6 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import Any, Dict, List, Optional
+from typing import Any, Dict, List
 from xml.etree import ElementTree
 
 from .dopbase import DopBase
@@ -15,8 +15,10 @@ from .utils import dataclass_fields_asdict
 class NegOutputParam(NamedElement):
     dop_base_ref: OdxLinkRef
 
-    def __post_init__(self) -> None:
-        self._dop: Optional[DopBase] = None
+    @property
+    def dop(self) -> DopBase:
+        """The data object property describing this parameter."""
+        return self._dop
 
     @staticmethod
     def from_et(et_element: ElementTree.Element,
@@ -31,12 +33,7 @@ class NegOutputParam(NamedElement):
         return {}
 
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
-        self._dop = odxlinks.resolve(self.dop_base_ref)
+        self._dop = odxlinks.resolve(self.dop_base_ref, DopBase)
 
     def _resolve_snrefs(self, context: SnRefContext) -> None:
         pass
-
-    @property
-    def dop(self) -> Optional[DopBase]:
-        """The data object property describing this parameter."""
-        return self._dop

odxtools/odxlink.py

@@ -277,24 +277,40 @@ class OdxLinkDatabase:
 @overload
 def resolve_snref(target_short_name: str,
                   items: Iterable[OdxNamed],
-                  expected_type: None = None) -> Any:
+                  expected_type: None = None,
+                  *,
+                  lenient: None = None) -> Any:
     """Resolve a short name reference given a sequence of candidate objects"""
     ...
 
 
 @overload
-def resolve_snref(target_short_name: str, items: Iterable[OdxNamed],
-                  expected_type: Type[TNamed]) -> TNamed:
+def resolve_snref(target_short_name: str,
+                  items: Iterable[OdxNamed],
+                  expected_type: Type[TNamed],
+                  *,
+                  lenient: None = None) -> TNamed:
+    ...
+
+
+@overload
+def resolve_snref(target_short_name: str,
+                  items: Iterable[OdxNamed],
+                  expected_type: Type[TNamed],
+                  *,
+                  lenient: bool = True) -> Optional[TNamed]:
     ...
 
 
 def resolve_snref(target_short_name: str,
                   items: Iterable[OdxNamed],
-                  expected_type: Any = None) -> Any:
+                  expected_type: Any = None,
+                  lenient: Optional[bool] = None) -> Any:
     candidates = [x for x in items if x.short_name == target_short_name]
 
     if not candidates:
-        odxraise(f"Cannot resolve short name reference to '{target_short_name}'")
+        if not lenient:
+            odxraise(f"Cannot resolve short name reference to '{target_short_name}'")
         return None
     elif len(candidates) > 1:
         odxraise(f"Cannot uniquely resolve short name reference to '{target_short_name}'")

odxtools/odxtypes.py

@@ -1,7 +1,7 @@
 # SPDX-License-Identifier: MIT
 from enum import Enum
-from typing import (TYPE_CHECKING, Any, Callable, Dict, Iterable, Optional, Tuple, Type, Union,
-                    overload)
+from typing import (TYPE_CHECKING, Any, Callable, Dict, Iterable, Optional, SupportsBytes, Tuple,
+                    Type, Union, overload)
 from xml.etree import ElementTree
 
 from .exceptions import odxassert, odxraise, odxrequire
@@ -16,7 +16,8 @@ def bytefield_to_bytearray(bytefield: str) -> bytearray:
     return bytearray([int(x, 16) for x in bytes_string])
 
 
-AtomicOdxType = Union[str, int, float, bytes]
+BytesTypes = (bytearray, bytes, SupportsBytes)
+AtomicOdxType = Union[str, int, float, bytearray, bytes]
 
 # dictionary mapping short names to a Parameter that needs to be
 # specified. Complex parameters (structures) may contain
@@ -135,8 +136,8 @@ def compare_odx_values(a: AtomicOdxType, b: AtomicOdxType) -> int:
 
     # bytefields are treated like long integers: to pad the shorter
     # object with zeros and treat the results like strings.
-    if isinstance(a, (bytes, bytearray)):
-        if not isinstance(b, (bytes, bytearray)):
+    if isinstance(a, BytesTypes):
+        if not isinstance(b, BytesTypes):
             odxraise()
 
         obj_len = max(len(a), len(b))
@@ -237,7 +238,7 @@ class DataType(Enum):
             return True
         elif expected_type is float and isinstance(value, (int, float)):
             return True
-        elif self == DataType.A_BYTEFIELD and isinstance(value, (bytearray, bytes)):
+        elif self == DataType.A_BYTEFIELD and isinstance(value, BytesTypes):
             return True
         else:
             return False

odxtools/outputparam.py

@@ -18,10 +18,19 @@ class OutputParam(IdentifiableElement):
     dop_base_ref: OdxLinkRef
     semantic: Optional[str]
 
+    @property
+    def dop(self) -> DopBase:
+        return self._dop
+
+    @deprecated(details="use .dop")  # type: ignore[misc]
+    def dop_base(self) -> DopBase:
+        return self._dop
+
     @staticmethod
     def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "OutputParam":
 
         kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, doc_frags))
+
         dop_base_ref = odxrequire(OdxLinkRef.from_et(et_element.find("DOP-BASE-REF"), doc_frags))
         semantic = et_element.get("SEMANTIC")
 
@@ -35,11 +44,3 @@ class OutputParam(IdentifiableElement):
 
     def _resolve_snrefs(self, context: SnRefContext) -> None:
         pass
-
-    @property
-    def dop(self) -> DopBase:
-        return self._dop
-
-    @deprecated(details="use .dop")  # type: ignore[misc]
-    def dop_base(self) -> DopBase:
-        return self._dop

odxtools/parameterinfo.py

@@ -73,7 +73,7 @@ def parameter_info(param_list: Iterable[Parameter], quoted_names: bool = False)
     of = StringIO()
     for param in param_list:
         if isinstance(param, CodedConstParameter):
-            of.write(f"{q}{param.short_name}{q}: const = {param._coded_value_str}\n")
+            of.write(f"{q}{param.short_name}{q}: const = {param.coded_value_raw}\n")
             continue
         elif isinstance(param, MatchingRequestParameter):
             of.write(f"{q}{param.short_name}{q}: <matches request>\n")

odxtools/parameters/codedconstparameter.py

@@ -1,7 +1,7 @@
 # SPDX-License-Identifier: MIT
 import warnings
 from dataclasses import dataclass
-from typing import Any, Dict, List, Optional
+from typing import Any, Dict, List, Optional, cast
 from xml.etree import ElementTree
 
 from typing_extensions import override
@@ -20,8 +20,27 @@ from .parameter import Parameter, ParameterType
 @dataclass
 class CodedConstParameter(Parameter):
 
+    coded_value_raw: str
     diag_coded_type: DiagCodedType
-    coded_value: AtomicOdxType
+
+    @property
+    @override
+    def parameter_type(self) -> ParameterType:
+        return "CODED-CONST"
+
+    @property
+    @override
+    def is_required(self) -> bool:
+        return False
+
+    @property
+    @override
+    def is_settable(self) -> bool:
+        return False
+
+    @property
+    def coded_value(self) -> AtomicOdxType:
+        return self._coded_value
 
     @staticmethod
     @override
@@ -30,18 +49,16 @@ class CodedConstParameter(Parameter):
 
         kwargs = dataclass_fields_asdict(Parameter.from_et(et_element, doc_frags))
 
+        coded_value_raw = odxrequire(et_element.findtext("CODED-VALUE"))
         dct_elem = odxrequire(et_element.find("DIAG-CODED-TYPE"))
         diag_coded_type = create_any_diag_coded_type_from_et(dct_elem, doc_frags)
-        coded_value = diag_coded_type.base_data_type.from_string(
-            odxrequire(et_element.findtext("CODED-VALUE")))
 
         return CodedConstParameter(
-            diag_coded_type=diag_coded_type, coded_value=coded_value, **kwargs)
+            coded_value_raw=coded_value_raw, diag_coded_type=diag_coded_type, **kwargs)
 
-    @property
-    @override
-    def parameter_type(self) -> ParameterType:
-        return "CODED-CONST"
+    def __post_init__(self) -> None:
+        self._coded_value = cast(
+            AtomicOdxType, self.diag_coded_type.base_data_type.from_string(self.coded_value_raw))
 
     @override
     def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
@@ -59,16 +76,6 @@ class CodedConstParameter(Parameter):
     def internal_data_type(self) -> DataType:
         return self.diag_coded_type.base_data_type
 
-    @property
-    @override
-    def is_required(self) -> bool:
-        return False
-
-    @property
-    @override
-    def is_settable(self) -> bool:
-        return False
-
     @override
     def _encode_positioned_into_pdu(self, physical_value: Optional[ParameterValue],
                                     encode_state: EncodeState) -> None:
@@ -91,7 +98,7 @@ class CodedConstParameter(Parameter):
             warnings.warn(
                 f"Coded constant parameter does not match! "
                 f"The parameter {self.short_name} expected coded "
-                f"value {str(self._coded_value_str)} but got {str(coded_val)} "
+                f"value {str(self.coded_value)} but got {str(coded_val)} "
                 f"at byte position {decode_state.cursor_byte_position} "
                 f"in coded message {decode_state.coded_message.hex()}.",
                 DecodeError,
@@ -100,12 +107,6 @@ class CodedConstParameter(Parameter):
 
         return coded_val
 
-    @property
-    def _coded_value_str(self) -> str:
-        if isinstance(self.coded_value, bytes):
-            return self.coded_value.hex()
-        return str(self.coded_value)
-
     def get_description_of_valid_values(self) -> str:
         """return a human-understandable description of valid physical values"""
-        return f"Constant internal value: {self._coded_value_str}"
+        return f"Constant internal value: {str(self.coded_value)}"

odxtools/parameters/dynamicparameter.py

@@ -16,15 +16,6 @@ from .parameter import Parameter, ParameterType
 @dataclass
 class DynamicParameter(Parameter):
 
-    @staticmethod
-    @override
-    def from_et(et_element: ElementTree.Element,
-                doc_frags: List[OdxDocFragment]) -> "DynamicParameter":
-
-        kwargs = dataclass_fields_asdict(Parameter.from_et(et_element, doc_frags))
-
-        return DynamicParameter(**kwargs)
-
     @property
     @override
     def parameter_type(self) -> ParameterType:
@@ -40,6 +31,15 @@ class DynamicParameter(Parameter):
     def is_settable(self) -> bool:
         raise NotImplementedError(".is_settable for a DynamicParameter")
 
+    @staticmethod
+    @override
+    def from_et(et_element: ElementTree.Element,
+                doc_frags: List[OdxDocFragment]) -> "DynamicParameter":
+
+        kwargs = dataclass_fields_asdict(Parameter.from_et(et_element, doc_frags))
+
+        return DynamicParameter(**kwargs)
+
     @override
     def _encode_positioned_into_pdu(self, physical_value: Optional[ParameterValue],
                                     encode_state: EncodeState) -> None:

odxtools/parameters/lengthkeyparameter.py

@@ -28,6 +28,24 @@ class LengthKeyParameter(ParameterWithDOP):
 
     odx_id: OdxLinkId
 
+    @property
+    @override
+    def parameter_type(self) -> ParameterType:
+        return "LENGTH-KEY"
+
+    @property
+    @override
+    def is_required(self) -> bool:
+        return False
+
+    @property
+    @override
+    def is_settable(self) -> bool:
+        # length keys can be explicitly set, but they do not need to
+        # be because they can be implicitly determined by the length
+        # of the corresponding field
+        return True
+
     @staticmethod
     @override
     def from_et(et_element: ElementTree.Element,
@@ -39,11 +57,6 @@ class LengthKeyParameter(ParameterWithDOP):
 
         return LengthKeyParameter(odx_id=odx_id, **kwargs)
 
-    @property
-    @override
-    def parameter_type(self) -> ParameterType:
-        return "LENGTH-KEY"
-
     @override
     def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
         result = super()._build_odxlinks()
@@ -52,19 +65,6 @@ class LengthKeyParameter(ParameterWithDOP):
 
         return result
 
-    @property
-    @override
-    def is_required(self) -> bool:
-        return False
-
-    @property
-    @override
-    def is_settable(self) -> bool:
-        # length keys can be explicitly set, but they do not need to
-        # be because they can be implicitly determined by the length
-        # of the corresponding field
-        return True
-
     @override
     @final
     def _encode_positioned_into_pdu(self, physical_value: Optional[ParameterValue],

odxtools/parameters/matchingrequestparameter.py

@@ -19,6 +19,21 @@ class MatchingRequestParameter(Parameter):
     request_byte_position: int
     byte_length: int
 
+    @property
+    @override
+    def parameter_type(self) -> ParameterType:
+        return "MATCHING-REQUEST-PARAM"
+
+    @property
+    @override
+    def is_required(self) -> bool:
+        return False
+
+    @property
+    @override
+    def is_settable(self) -> bool:
+        return False
+
     @staticmethod
     @override
     def from_et(et_element: ElementTree.Element,
@@ -32,25 +47,10 @@ class MatchingRequestParameter(Parameter):
         return MatchingRequestParameter(
             request_byte_position=request_byte_position, byte_length=byte_length, **kwargs)
 
-    @property
-    @override
-    def parameter_type(self) -> ParameterType:
-        return "MATCHING-REQUEST-PARAM"
-
     @override
     def get_static_bit_length(self) -> Optional[int]:
         return 8 * self.byte_length
 
-    @property
-    @override
-    def is_required(self) -> bool:
-        return False
-
-    @property
-    @override
-    def is_settable(self) -> bool:
-        return False
-
     @override
     def _encode_positioned_into_pdu(self, physical_value: Optional[ParameterValue],
                                     encode_state: EncodeState) -> None: