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

odxtools/odxtypes.py

@@ -1,11 +1,10 @@
 # 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
-from .utils import BytesTypes
 
 if TYPE_CHECKING:
     from odxtools.diagnostictroublecode import DiagnosticTroubleCode
@@ -17,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

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:

odxtools/parameters/nrcconstparameter.py

@@ -34,8 +34,31 @@ class NrcConstParameter(Parameter):
 
     """
 
+    coded_values_raw: List[str]
     diag_coded_type: DiagCodedType
-    coded_values: List[AtomicOdxType]
+
+    @property
+    @override
+    def parameter_type(self) -> ParameterType:
+        return "NRC-CONST"
+
+    @property
+    @override
+    def is_required(self) -> bool:
+        return False
+
+    @property
+    @override
+    def is_settable(self) -> bool:
+        return False
+
+    @property
+    def internal_data_type(self) -> DataType:
+        return self.diag_coded_type.base_data_type
+
+    @property
+    def coded_values(self) -> List[AtomicOdxType]:
+        return self._coded_values
 
     @staticmethod
     @override
@@ -44,20 +67,19 @@ class NrcConstParameter(Parameter):
 
         kwargs = dataclass_fields_asdict(Parameter.from_et(et_element, doc_frags))
 
+        coded_values_raw = [
+            odxrequire(x.text) for x in et_element.iterfind("CODED-VALUES/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_values = [
-            diag_coded_type.base_data_type.from_string(odxrequire(val.text))
-            for val in et_element.iterfind("CODED-VALUES/CODED-VALUE")
-        ]
 
         return NrcConstParameter(
-            diag_coded_type=diag_coded_type, coded_values=coded_values, **kwargs)
+            coded_values_raw=coded_values_raw, diag_coded_type=diag_coded_type, **kwargs)
 
-    @property
-    @override
-    def parameter_type(self) -> ParameterType:
-        return "NRC-CONST"
+    def __post_init__(self) -> None:
+        self._coded_values = [
+            self.diag_coded_type.base_data_type.from_string(val) for val in self.coded_values_raw
+        ]
 
     @override
     def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
@@ -71,20 +93,6 @@ class NrcConstParameter(Parameter):
     def get_static_bit_length(self) -> Optional[int]:
         return self.diag_coded_type.get_static_bit_length()
 
-    @property
-    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:

odxtools/parameters/parameter.py

@@ -42,11 +42,39 @@ class Parameter(NamedElement):
     non-positionable parameter types.
 
     """
+    sdgs: List[SpecialDataGroup]
+    semantic: Optional[str]
     oid: Optional[str]
     byte_position: Optional[int]
     bit_position: Optional[int]
-    semantic: Optional[str]
-    sdgs: List[SpecialDataGroup]
+
+    @property
+    def parameter_type(self) -> ParameterType:
+        raise NotImplementedError(
+            ".parameter_type is not implemented by the concrete parameter class")
+
+    @property
+    def is_required(self) -> bool:
+        """True if the parameter must be explicitly specified when
+        encoding a message.
+
+        Required parameters are always settable, and parameters which
+        have a default value are settable but not required to be
+        specified.
+
+        """
+        raise NotImplementedError(".is_required is not implemented by the concrete parameter class")
+
+    @property
+    def is_settable(self) -> bool:
+        """True if the parameter can be specified when encoding a
+        message.
+
+        Required parameters are always settable, and parameters which
+        have a default value are settable but not required to be
+        specified.
+        """
+        raise NotImplementedError(".is_settable is not implemented by the concrete parameter class")
 
     @staticmethod
     @override
@@ -54,24 +82,22 @@ class Parameter(NamedElement):
 
         kwargs = dataclass_fields_asdict(NamedElement.from_et(et_element, doc_frags))
 
-        oid = et_element.get("OID")
-        semantic = et_element.get("SEMANTIC")
         sdgs = [
             SpecialDataGroup.from_et(sdge, doc_frags) for sdge in et_element.iterfind("SDGS/SDG")
         ]
-
+        semantic = et_element.attrib.get("SEMANTIC")
+        oid = et_element.attrib.get("OID")
         byte_position_str = et_element.findtext("BYTE-POSITION")
-        bit_position_str = et_element.findtext("BIT-POSITION")
-
         byte_position = int(byte_position_str) if byte_position_str is not None else None
+        bit_position_str = et_element.findtext("BIT-POSITION")
         bit_position = int(bit_position_str) if bit_position_str is not None else None
 
         return Parameter(
+            sdgs=sdgs,
+            semantic=semantic,
             oid=oid,
             byte_position=byte_position,
             bit_position=bit_position,
-            semantic=semantic,
-            sdgs=sdgs,
             **kwargs)
 
     def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
@@ -90,37 +116,9 @@ class Parameter(NamedElement):
         for sdg in self.sdgs:
             sdg._resolve_snrefs(context)
 
-    @property
-    def parameter_type(self) -> ParameterType:
-        raise NotImplementedError(
-            ".parameter_type is not implemented by the concrete parameter class")
-
     def get_static_bit_length(self) -> Optional[int]:
         return None
 
-    @property
-    def is_required(self) -> bool:
-        """True if the parameter must be explicitly specified when
-        encoding a message.
-
-        Required parameters are always settable, and parameters which
-        have a default value are settable but not required to be
-        specified.
-
-        """
-        raise NotImplementedError(".is_required is not implemented by the concrete parameter class")
-
-    @property
-    def is_settable(self) -> bool:
-        """True if the parameter can be specified when encoding a
-        message.
-
-        Required parameters are always settable, and parameters which
-        have a default value are settable but not required to be
-        specified.
-        """
-        raise NotImplementedError(".is_settable is not implemented by the concrete parameter class")
-
     @final
     def encode_into_pdu(self, physical_value: Optional[ParameterValue],
                         encode_state: EncodeState) -> None:

odxtools/parameters/parameterwithdop.py

@@ -24,6 +24,12 @@ class ParameterWithDOP(Parameter):
     dop_ref: Optional[OdxLinkRef]
     dop_snref: Optional[str]
 
+    @property
+    def dop(self) -> DopBase:
+        """This is usually a DataObjectProperty or a Structure object"""
+
+        return self._dop
+
     @staticmethod
     @override
     def from_et(et_element: ElementTree.Element,
@@ -63,12 +69,6 @@ class ParameterWithDOP(Parameter):
             ddds = odxrequire(context.diag_layer).diag_data_dictionary_spec
             self._dop = resolve_snref(self.dop_snref, ddds.all_data_object_properties, DopBase)
 
-    @property
-    def dop(self) -> DopBase:
-        """This is usually a DataObjectProperty or a Structure object"""
-
-        return self._dop
-
     @override
     def get_static_bit_length(self) -> Optional[int]:
         if self._dop is not None:

odxtools/parameters/physicalconstantparameter.py

@@ -19,9 +19,27 @@ from .parameterwithdop import ParameterWithDOP
 
 @dataclass
 class PhysicalConstantParameter(ParameterWithDOP):
-
     physical_constant_value_raw: str
 
+    @property
+    @override
+    def parameter_type(self) -> ParameterType:
+        return "PHYS-CONST"
+
+    @property
+    @override
+    def is_required(self) -> bool:
+        return False
+
+    @property
+    @override
+    def is_settable(self) -> bool:
+        return False
+
+    @property
+    def physical_constant_value(self) -> ParameterValue:
+        return self._physical_constant_value
+
     @staticmethod
     @override
     def from_et(et_element: ElementTree.Element,
@@ -34,11 +52,6 @@ class PhysicalConstantParameter(ParameterWithDOP):
         return PhysicalConstantParameter(
             physical_constant_value_raw=physical_constant_value_raw, **kwargs)
 
-    @property
-    @override
-    def parameter_type(self) -> ParameterType:
-        return "PHYS-CONST"
-
     @override
     def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
         return super()._build_odxlinks()
@@ -58,20 +71,6 @@ class PhysicalConstantParameter(ParameterWithDOP):
         base_data_type = dop.physical_type.base_data_type
         self._physical_constant_value = base_data_type.from_string(self.physical_constant_value_raw)
 
-    @property
-    def physical_constant_value(self) -> ParameterValue:
-        return self._physical_constant_value
-
-    @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:

odxtools/parameters/reservedparameter.py

@@ -18,17 +18,6 @@ from .parameter import Parameter, ParameterType
 class ReservedParameter(Parameter):
     bit_length: int
 
-    @staticmethod
-    @override
-    def from_et(et_element: ElementTree.Element,
-                doc_frags: List[OdxDocFragment]) -> "ReservedParameter":
-
-        kwargs = dataclass_fields_asdict(Parameter.from_et(et_element, doc_frags))
-
-        bit_length = int(odxrequire(et_element.findtext("BIT-LENGTH")))
-
-        return ReservedParameter(bit_length=bit_length, **kwargs)
-
     @property
     @override
     def parameter_type(self) -> ParameterType:
@@ -44,6 +33,16 @@ class ReservedParameter(Parameter):
     def is_settable(self) -> bool:
         return False
 
+    @staticmethod
+    @override
+    def from_et(et_element: ElementTree.Element,
+                doc_frags: List[OdxDocFragment]) -> "ReservedParameter":
+        kwargs = dataclass_fields_asdict(Parameter.from_et(et_element, doc_frags))
+
+        bit_length = int(odxrequire(et_element.findtext("BIT-LENGTH")))
+
+        return ReservedParameter(bit_length=bit_length, **kwargs)
+
     @override
     def get_static_bit_length(self) -> Optional[int]:
         return self.bit_length

odxtools/parameters/systemparameter.py

@@ -29,17 +29,6 @@ PREDEFINED_SYSPARAM_VALUES = [
 class SystemParameter(ParameterWithDOP):
     sysparam: str
 
-    @staticmethod
-    @override
-    def from_et(et_element: ElementTree.Element,
-                doc_frags: List[OdxDocFragment]) -> "SystemParameter":
-
-        kwargs = dataclass_fields_asdict(ParameterWithDOP.from_et(et_element, doc_frags))
-
-        sysparam = odxrequire(et_element.get("SYSPARAM"))
-
-        return SystemParameter(sysparam=sysparam, **kwargs)
-
     @property
     @override
     def parameter_type(self) -> ParameterType:
@@ -58,6 +47,16 @@ class SystemParameter(ParameterWithDOP):
     def is_settable(self) -> bool:
         return True
 
+    @staticmethod
+    @override
+    def from_et(et_element: ElementTree.Element,
+                doc_frags: List[OdxDocFragment]) -> "SystemParameter":
+        kwargs = dataclass_fields_asdict(ParameterWithDOP.from_et(et_element, doc_frags))
+
+        sysparam = odxrequire(et_element.get("SYSPARAM"))
+
+        return SystemParameter(sysparam=sysparam, **kwargs)
+
     @override
     def _encode_positioned_into_pdu(self, physical_value: Optional[ParameterValue],
                                     encode_state: EncodeState) -> None: