odxtools 6.7.0__py3-none-any.whl → 7.0.0__py3-none-any.whl

odxtools/parameters/tablestructparameter.py

@@ -1,14 +1,13 @@
 # SPDX-License-Identifier: MIT
-import warnings
 from dataclasses import dataclass
 from typing import TYPE_CHECKING, Any, Dict, List, Optional, cast
 from xml.etree import ElementTree
 
-from typing_extensions import override
+from typing_extensions import final, override
 
 from ..decodestate import DecodeState
 from ..encodestate import EncodeState
-from ..exceptions import DecodeError, EncodeError, OdxWarning, odxraise, odxrequire
+from ..exceptions import DecodeError, EncodeError, odxraise, odxrequire
 from ..odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef
 from ..odxtypes import ParameterValue
 from ..utils import dataclass_fields_asdict
@@ -61,15 +60,31 @@ class TableStructParameter(Parameter):
             self._table_key = odxlinks.resolve(self.table_key_ref, TableKeyParameter)
 
     @override
+    @final
     def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
+        raise RuntimeError(f"Calling TableStructParameter._resolve_snref() is not allowed. "
+                           f"Use ._table_struct_resolve_snrefs() instead.")
+
+    def _table_struct_resolve_snrefs(self, diag_layer: "DiagLayer", *,
+                                     param_list: List[Parameter]) -> None:
         super()._resolve_snrefs(diag_layer)
 
         if self.table_key_snref is not None:
-            warnings.warn(
-                "Table keys cannot yet be defined using SNREFs"
-                " in TableStructParameters.",
-                OdxWarning,
-                stacklevel=1)
+            tk_candidates = [p for p in param_list if p.short_name == self.table_key_snref]
+            if len(tk_candidates) > 1:
+                odxraise(f"Short name reference '{self.table_key_snref}' could "
+                         f"not be uniquely resolved.")
+            elif len(tk_candidates) == 0:
+                odxraise(f"Short name reference '{self.table_key_snref}' could "
+                         f"not be resolved.")
+                return
+
+            tk = tk_candidates[0]
+            if not isinstance(tk, TableKeyParameter):
+                odxraise(f"Table struct '{self.short_name}' references non-TableKey parameter "
+                         f"`{self.table_key_snref}' as its table key.")
+
+            self._table_key = tk
 
     @property
     def table_key(self) -> TableKeyParameter:
@@ -86,71 +101,76 @@ class TableStructParameter(Parameter):
         return True
 
     @override
-    def get_coded_value_as_bytes(self, encode_state: EncodeState) -> bytes:
-        physical_value = encode_state.parameter_values.get(self.short_name)
+    def _encode_positioned_into_pdu(self, physical_value: Optional[ParameterValue],
+                                    encode_state: EncodeState) -> None:
 
-        if not isinstance(physical_value, tuple) or \
+        if not isinstance(physical_value, (tuple, list)) or \
            len(physical_value) != 2 or \
            not isinstance(physical_value[0], str):
-            raise EncodeError(f"The physical value of TableStructParameter 'self.short_name' "
-                              f"must be a tuple with  the short name of the selected table "
-                              f"row as the first element and the physical value for the "
-                              f"row's structure or DOP as the second.")
+            odxraise(
+                f"The physical value of TableStructParameter 'self.short_name' "
+                f"must be a tuple containing the short name of the selected table "
+                f"row as the first element and the physical value for the "
+                f"row's structure or DOP as the second.", EncodeError)
 
         tr_short_name = physical_value[0]
 
         # make sure that the same table row is selected for all
         # TABLE-STRUCT parameters that are using the same key
         tk_short_name = self.table_key.short_name
-        tk_value = encode_state.parameter_values.get(tk_short_name)
+        tk_value = encode_state.table_keys.get(tk_short_name)
         if tk_value is None:
             # no value for the key has been set yet. Set it to the
             # value which we are using right now
-            encode_state.parameter_values[tk_short_name] = tr_short_name
+            encode_state.table_keys[tk_short_name] = tr_short_name
         elif tk_value != tr_short_name:
-            raise EncodeError(f"Cannot determine a unique value for table key '{tk_short_name}':  "
-                              f"Requested are '{tk_value}' and '{tr_short_name}'")
+            odxraise(
+                f"Cannot determine a unique value for table key '{tk_short_name}':  "
+                f"Requested are '{tk_value}' and '{tr_short_name}'", EncodeError)
+            return
 
         # deal with the static case (i.e., the table row is selected
         # by the table key object itself)
-        if self.table_key.table_row is not None and \
-           self.table_key.table_row.short_name != tr_short_name:
-            raise EncodeError(f"The selected table row for the {self.short_name} "
-                              f"parameter must be '{self.table_key.table_row.short_name}' "
-                              f"(is: '{tr_short_name}')")
+        if self.table_key.table_row is not None:
+            if tr_short_name is not None and self.table_key.table_row.short_name != tr_short_name:
+                odxraise(
+                    f"The selected table row for the {self.short_name} "
+                    f"parameter must be '{self.table_key.table_row.short_name}' "
+                    f"instead of '{tr_short_name}'", EncodeError)
+                return
+
+            tr_short_name = self.table_key.table_row.short_name
 
         # encode the user specified value using the structure (or DOP)
         # of the selected table row
         table = self.table_key.table
         candidate_trs = [tr for tr in table.table_rows if tr.short_name == tr_short_name]
-        if len(candidate_trs) != 1:
-            raise EncodeError(f"Could not uniquely resolve a table row named "
-                              f"'{tr_short_name}' in table '{table.short_name}' ")
+        if len(candidate_trs) == 0:
+            odxraise(
+                f"Could not find a table row named "
+                f"'{tr_short_name}' in table '{table.short_name}'", EncodeError)
+            return
+        elif len(candidate_trs) > 1:
+            odxraise(
+                f"Found multiple table rows named "
+                f"'{tr_short_name}' in table '{table.short_name}'", EncodeError)
+
         tr = candidate_trs[0]
         tr_value = physical_value[1]
 
-        bit_position = self.bit_position or 0
         if tr.structure is not None:
             # the selected table row references a structure
-            inner_encode_state = EncodeState(
-                coded_message=bytearray(b''),
-                parameter_values=tr_value,
-                triggering_request=encode_state.triggering_request)
-
-            return tr.structure.convert_physical_to_bytes(
-                tr_value, inner_encode_state, bit_position=bit_position)
+            tr.structure.encode_into_pdu(tr_value, encode_state)
+            return
 
         # if the table row does not reference a structure, it must
         # point to a DOP!
         if tr.dop is None:
-            odxraise()
+            odxraise(f"Neither a structure nor a DOP has been defined for table row"
+                     f"'{tr.short_name}'")
+            return
 
-        return tr.dop.convert_physical_to_bytes(
-            tr_value, encode_state=encode_state, bit_position=bit_position)
-
-    @override
-    def encode_into_pdu(self, encode_state: EncodeState) -> bytes:
-        return super().encode_into_pdu(encode_state)
+        tr.dop.encode_into_pdu(tr_value, encode_state)
 
     @override
     def _decode_positioned_from_pdu(self, decode_state: DecodeState) -> ParameterValue:

odxtools/parameters/valueparameter.py

@@ -7,9 +7,9 @@ from typing_extensions import override
 
 from ..dataobjectproperty import DataObjectProperty
 from ..encodestate import EncodeState
-from ..exceptions import odxraise, odxrequire
+from ..exceptions import EncodeError, odxraise, odxrequire
 from ..odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
-from ..odxtypes import AtomicOdxType
+from ..odxtypes import AtomicOdxType, ParameterValue
 from ..utils import dataclass_fields_asdict
 from .parameter import ParameterType
 from .parameterwithdop import ParameterWithDOP
@@ -77,16 +77,14 @@ class ValueParameter(ParameterWithDOP):
         return True
 
     @override
-    def get_coded_value_as_bytes(self, encode_state: EncodeState) -> bytes:
-        physical_value = encode_state.parameter_values.get(self.short_name,
-                                                           self.physical_default_value)
+    def _encode_positioned_into_pdu(self, physical_value: Optional[ParameterValue],
+                                    encode_state: EncodeState) -> None:
+
+        if physical_value is None:
+            physical_value = self._physical_default_value
         if physical_value is None:
-            raise TypeError(f"A value for parameter '{self.short_name}' must be specified"
-                            f" as the parameter does not exhibit a default.")
-        dop = odxrequire(
-            self.dop,
-            f"Param {self.short_name} does not have a DOP. Maybe resolving references failed?")
-
-        bit_position_int = self.bit_position if self.bit_position is not None else 0
-        return dop.convert_physical_to_bytes(
-            physical_value, encode_state=encode_state, bit_position=bit_position_int)
+            odxraise(
+                f"A value for parameter '{self.short_name}' must be specified"
+                f" because the parameter does not exhibit a default.", EncodeError)
+
+        self.dop.encode_into_pdu(physical_value, encode_state=encode_state)

odxtools/paramlengthinfotype.py

@@ -2,10 +2,12 @@
 from dataclasses import dataclass
 from typing import TYPE_CHECKING, Any, Dict, cast
 
+from typing_extensions import override
+
 from .decodestate import DecodeState
 from .diagcodedtype import DctType, DiagCodedType
 from .encodestate import EncodeState
-from .exceptions import odxraise
+from .exceptions import EncodeError, odxraise
 from .odxlink import OdxLinkDatabase, OdxLinkId, OdxLinkRef
 from .odxtypes import AtomicOdxType, DataType
 
@@ -43,35 +45,43 @@ class ParamLengthInfoType(DiagCodedType):
     def length_key(self) -> "LengthKeyParameter":
         return self._length_key
 
-    def convert_internal_to_bytes(self, internal_value: AtomicOdxType, encode_state: EncodeState,
-                                  bit_position: int) -> bytes:
-        bit_length = encode_state.parameter_values.get(self.length_key.short_name, None)
+    @override
+    def encode_into_pdu(self, internal_value: AtomicOdxType, encode_state: EncodeState) -> None:
+        bit_length = encode_state.length_keys.get(self.length_key.short_name)
 
         if bit_length is None:
+            # the length key is implicit, i.e., we need to set the
+            # value for the length key in the encode_state based on
+            # the value passed here.
             if self.base_data_type in [
                     DataType.A_BYTEFIELD,
                     DataType.A_ASCIISTRING,
                     DataType.A_UTF8STRING,
             ]:
-                bit_length = 8 * len(internal_value)  # type: ignore[arg-type]
-            if self.base_data_type in [DataType.A_UNICODE2STRING]:
-                bit_length = 16 * len(internal_value)  # type: ignore[arg-type]
-
-            if self.base_data_type in [DataType.A_INT32, DataType.A_UINT32]:
+                bit_length = 8 * len(cast(str, internal_value))
+            elif self.base_data_type in [DataType.A_UNICODE2STRING]:
+                bit_length = 16 * len(cast(str, internal_value))
+            elif self.base_data_type in [DataType.A_INT32, DataType.A_UINT32]:
                 bit_length = int(internal_value).bit_length()
                 if self.base_data_type == DataType.A_INT32:
                     bit_length += 1
                 # Round up
                 bit_length = ((bit_length + 7) // 8) * 8
-
-            encode_state.parameter_values[self.length_key.short_name] = bit_length
-
-        if bit_length is None:
-            odxraise()
-
-        return self._encode_internal_value(
-            internal_value,
-            bit_position=bit_position,
+            elif self.base_data_type == DataType.A_FLOAT32:
+                bit_length = 32
+            elif self.base_data_type == DataType.A_FLOAT64:
+                bit_length = 64
+            else:
+                odxraise(
+                    f"Cannot determine size of an object of type "
+                    f"{self.base_data_type.value}", EncodeError)
+                return
+
+            encode_state.length_keys[self.length_key.short_name] = bit_length
+
+        encode_state.emplace_atomic_value(
+            internal_value=internal_value,
+            used_mask=None,
             bit_length=bit_length,
             base_data_type=self.base_data_type,
             is_highlow_byte_order=self.is_highlow_byte_order,
@@ -82,7 +92,7 @@ class ParamLengthInfoType(DiagCodedType):
         if self.length_key.short_name not in decode_state.length_keys:
             odxraise(f"Unspecified mandatory length key parameter "
                      f"{self.length_key.short_name}")
-            decode_state.cursor_bit_position = None
+            decode_state.cursor_bit_position = 0
             return cast(None, AtomicOdxType)
 
         bit_length = decode_state.length_keys[self.length_key.short_name]
@@ -91,10 +101,8 @@ class ParamLengthInfoType(DiagCodedType):
             bit_length = 0
 
         # Extract the internal value and return.
-        value = decode_state.extract_atomic_value(
+        return decode_state.extract_atomic_value(
             bit_length,
             self.base_data_type,
             self.is_highlow_byte_order,
         )
-
-        return value

odxtools/request.py

@@ -4,7 +4,9 @@ from typing import List
 from xml.etree import ElementTree
 
 from .basicstructure import BasicStructure
+from .encodestate import EncodeState
 from .odxlink import OdxDocFragment
+from .odxtypes import ParameterValue
 from .utils import dataclass_fields_asdict
 
 
@@ -20,3 +22,10 @@ class Request(BasicStructure):
         kwargs = dataclass_fields_asdict(BasicStructure.from_et(et_element, doc_frags))
 
         return Request(**kwargs)
+
+    def encode(self, **kwargs: ParameterValue) -> bytes:
+        encode_state = EncodeState(is_end_of_pdu=True)
+
+        self.encode_into_pdu(physical_value=kwargs, encode_state=encode_state)
+
+        return encode_state.coded_message

odxtools/response.py

@@ -5,10 +5,10 @@ from typing import List, Optional, cast
 from xml.etree import ElementTree
 
 from .basicstructure import BasicStructure
+from .encodestate import EncodeState
 from .exceptions import odxraise
 from .odxlink import OdxDocFragment
 from .odxtypes import ParameterValue
-from .parameters.matchingrequestparameter import MatchingRequestParameter
 from .utils import dataclass_fields_asdict
 
 
@@ -38,17 +38,9 @@ class Response(BasicStructure):
 
         return Response(response_type=response_type, **kwargs)
 
-    def encode(self, coded_request: Optional[bytes] = None, **params: ParameterValue) -> bytes:
-        if coded_request is not None:
-            # Extract MATCHING-REQUEST-PARAMs from the coded
-            # request. TODO: this should be done by
-            # MatchingRequestParam itself!
-            for param in self.parameters:
-                if isinstance(param, MatchingRequestParameter):
-                    byte_pos = param.request_byte_position
-                    byte_length = param.byte_length
+    def encode(self, coded_request: Optional[bytes] = None, **kwargs: ParameterValue) -> bytes:
+        encode_state = EncodeState(triggering_request=coded_request, is_end_of_pdu=True)
 
-                    val = coded_request[byte_pos:byte_pos + byte_length]
-                    params[param.short_name] = val
+        self.encode_into_pdu(physical_value=kwargs, encode_state=encode_state)
 
-        return super().encode(coded_request=coded_request, **params)
+        return encode_state.coded_message

odxtools/standardlengthtype.py

@@ -1,11 +1,13 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import Optional
+from typing import Literal, Optional
+
+from typing_extensions import override
 
 from .decodestate import DecodeState
 from .diagcodedtype import DctType, DiagCodedType
 from .encodestate import EncodeState
-from .exceptions import odxassert, odxraise
+from .exceptions import odxassert, odxraise, odxrequire
 from .odxtypes import AtomicOdxType, DataType
 
 
@@ -20,6 +22,10 @@ class StandardLengthType(DiagCodedType):
     def dct_type(self) -> DctType:
         return "STANDARD-LENGTH-TYPE"
 
+    @property
+    def is_condensed(self) -> bool:
+        return self.is_condensed_raw is True
+
     def __post_init__(self) -> None:
         if self.bit_mask is not None:
             maskable_types = (DataType.A_UINT32, DataType.A_INT32, DataType.A_BYTEFIELD)
@@ -28,11 +34,43 @@ class StandardLengthType(DiagCodedType):
                 'Can not apply a bit_mask on a value of type {self.base_data_type}',
             )
 
+    def __get_raw_mask(self, internal_value: AtomicOdxType) -> Optional[bytes]:
+        """Returns a byte field where all bits that are used by the
+        DiagCoded type are set and all unused ones are not set.
+
+        If `None` is returned, all bits are used.
+        """
+        if self.bit_mask is None:
+            return None
+
+        if self.is_condensed:
+            odxraise("Condensed bit masks are not yet supported", NotImplementedError)
+            return
+
+        endianness: Literal["little", "big"] = "big"
+        if not self.is_highlow_byte_order and self.base_data_type in [
+                DataType.A_INT32, DataType.A_UINT32, DataType.A_FLOAT32, DataType.A_FLOAT64
+        ]:
+            # TODO (?): Technically, little endian A_UNICODE2STRING
+            # objects require a byte swap for each 16 bit letter, and
+            # thus also for the mask. I somehow doubt that this has
+            # been anticipated by the standard, though...
+            endianness = "little"
+
+        sz: int
+        if isinstance(internal_value, (bytes, bytearray)):
+            sz = len(internal_value)
+        else:
+            sz = (odxrequire(self.get_static_bit_length()) + 7) // 8
+
+        return self.bit_mask.to_bytes(sz, endianness)
+
     def __apply_mask(self, internal_value: AtomicOdxType) -> AtomicOdxType:
         if self.bit_mask is None:
             return internal_value
-        if self.is_condensed_raw is True:
-            raise NotImplementedError("Serialization of condensed bit mask is not supported")
+        if self.is_condensed:
+            odxraise("Serialization of condensed bit mask is not supported", NotImplementedError)
+            return
         if isinstance(internal_value, int):
             return internal_value & self.bit_mask
         if isinstance(internal_value, bytes):
@@ -46,16 +84,16 @@ class StandardLengthType(DiagCodedType):
     def get_static_bit_length(self) -> Optional[int]:
         return self.bit_length
 
-    def convert_internal_to_bytes(self, internal_value: AtomicOdxType, encode_state: EncodeState,
-                                  bit_position: int) -> bytes:
-        return self._encode_internal_value(
-            self.__apply_mask(internal_value),
-            bit_position,
-            self.bit_length,
-            self.base_data_type,
-            is_highlow_byte_order=self.is_highlow_byte_order,
-        )
+    @override
+    def encode_into_pdu(self, internal_value: AtomicOdxType, encode_state: EncodeState) -> None:
+        encode_state.emplace_atomic_value(
+            internal_value=self.__apply_mask(internal_value),
+            used_mask=self.__get_raw_mask(internal_value),
+            bit_length=self.bit_length,
+            base_data_type=self.base_data_type,
+            is_highlow_byte_order=self.is_highlow_byte_order)
 
+    @override
     def decode_from_pdu(self, decode_state: DecodeState) -> AtomicOdxType:
         internal_value = decode_state.extract_atomic_value(
             self.bit_length,

odxtools/staticfield.py

@@ -48,36 +48,32 @@ class StaticField(Field):
         super()._resolve_snrefs(diag_layer)
 
     @override
-    def convert_physical_to_bytes(
-        self,
-        physical_value: ParameterValue,
-        encode_state: EncodeState,
-        bit_position: int = 0,
-    ) -> bytes:
+    def encode_into_pdu(self, physical_value: ParameterValue, encode_state: EncodeState) -> None:
+
         if not isinstance(physical_value,
                           (tuple, list)) or len(physical_value) != self.fixed_number_of_items:
             odxraise(f"Value for static field '{self.short_name}' "
                      f"must be a list of size {self.fixed_number_of_items}")
 
-        result = bytearray()
         for val in physical_value:
             if not isinstance(val, dict):
                 odxraise(f"The individual parameter values for static field '{self.short_name}' "
                          f"must be dictionaries for structure '{self.structure.short_name}'")
 
-            data = self.structure.convert_physical_to_bytes(val, encode_state)
-
-            if len(data) > self.item_byte_size:
-                odxraise(f"Insufficient item byte size for static field {self.short_name}: "
-                         f"Is {self.item_byte_size} bytes, but need at least {len(data)} bytes")
-                data = data[:self.item_byte_size]
-            elif len(data) < self.item_byte_size:
+            pos_before = encode_state.cursor_byte_position
+            self.structure.encode_into_pdu(val, encode_state)
+            pos_after = encode_state.cursor_byte_position
+
+            if pos_after - pos_before > self.item_byte_size:
+                odxraise(
+                    f"Insufficient item byte size for static field {self.short_name}: "
+                    f"Is {self.item_byte_size} bytes, but need at least {pos_after - pos_before} bytes"
+                )
+                encode_state.cursor_byte_position = pos_before + self.item_byte_size
+            elif pos_after - pos_before < self.item_byte_size:
                 # add some padding bytes
-                data = data.ljust(self.item_byte_size, b'\x00')
-
-            result += data
-
-        return result
+                encode_state.emplace_bytes(b'\x00' * (self.item_byte_size -
+                                                      (pos_after - pos_before)))
 
     @override
     def decode_from_pdu(self, decode_state: DecodeState) -> ParameterValue:

odxtools/version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '6.7.0'
-__version_tuple__ = version_tuple = (6, 7, 0)
+__version__ = version = '7.0.0'
+__version_tuple__ = version_tuple = (7, 0, 0)

{odxtools-6.7.0.dist-info → odxtools-7.0.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: odxtools
-Version: 6.7.0
+Version: 7.0.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>