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

odxtools/diaglayerraw.py

@@ -1,7 +1,6 @@
 # SPDX-License-Identifier: MIT
 from copy import copy
 from dataclasses import dataclass
-from itertools import chain
 from typing import TYPE_CHECKING, Any, Dict, List, Optional, Union
 from xml.etree import ElementTree
 
@@ -202,76 +201,106 @@ class DiagLayerRaw(IdentifiableElement):
         """Construct a mapping from IDs to all objects that are contained in this diagnostic layer."""
         odxlinks = {self.odx_id: self}
 
-        for obj in chain(
-            [self.admin_data],
-                self.company_datas,
-                self.functional_classes,
-            [self.diag_data_dictionary_spec],
-                self.diag_comms,
-                self.requests,
-                self.positive_responses,
-                self.negative_responses,
-                self.global_negative_responses,
-                self.state_charts,
-                self.additional_audiences,
-                self.sdgs,
-                self.parent_refs,
-                self.communication_parameters,
-        ):
-            # the diag_comms may contain references.
-            if obj is None or isinstance(obj, OdxLinkRef):
+        if self.admin_data is not None:
+            odxlinks.update(self.admin_data._build_odxlinks())
+        if self.diag_data_dictionary_spec is not None:
+            odxlinks.update(self.diag_data_dictionary_spec._build_odxlinks())
+
+        for company_data in self.company_datas:
+            odxlinks.update(company_data._build_odxlinks())
+        for functional_class in self.functional_classes:
+            odxlinks.update(functional_class._build_odxlinks())
+        for diag_comm in self.diag_comms:
+            if isinstance(diag_comm, OdxLinkRef):
                 continue
-
-            odxlinks.update(obj._build_odxlinks())
+            odxlinks.update(diag_comm._build_odxlinks())
+        for request in self.requests:
+            odxlinks.update(request._build_odxlinks())
+        for positive_response in self.positive_responses:
+            odxlinks.update(positive_response._build_odxlinks())
+        for negative_response in self.negative_responses:
+            odxlinks.update(negative_response._build_odxlinks())
+        for global_negative_response in self.global_negative_responses:
+            odxlinks.update(global_negative_response._build_odxlinks())
+        for state_chart in self.state_charts:
+            odxlinks.update(state_chart._build_odxlinks())
+        for additional_audience in self.additional_audiences:
+            odxlinks.update(additional_audience._build_odxlinks())
+        for sdg in self.sdgs:
+            odxlinks.update(sdg._build_odxlinks())
+        for parent_ref in self.parent_refs:
+            odxlinks.update(parent_ref._build_odxlinks())
+        for communication_parameter in self.communication_parameters:
+            odxlinks.update(communication_parameter._build_odxlinks())
 
         return odxlinks
 
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
         """Recursively resolve all references."""
 
-        # do reference resolution for the objects that do not use
-        # short name references
-        for obj in chain(
-            [self.admin_data],
-                self.company_datas,
-                self.functional_classes,
-            [self.diag_data_dictionary_spec],
-                self.diag_comms,
-                self.requests,
-                self.positive_responses,
-                self.negative_responses,
-                self.global_negative_responses,
-                self.state_charts,
-                self.additional_audiences,
-                self.sdgs,
-                self.parent_refs,
-                self.communication_parameters,
-        ):
-            if obj is None or isinstance(obj, OdxLinkRef):
+        # do ODXLINK reference resolution
+        if self.admin_data is not None:
+            self.admin_data._resolve_odxlinks(odxlinks)
+        if self.diag_data_dictionary_spec is not None:
+            self.diag_data_dictionary_spec._resolve_odxlinks(odxlinks)
+
+        for company_data in self.company_datas:
+            company_data._resolve_odxlinks(odxlinks)
+        for functional_class in self.functional_classes:
+            functional_class._resolve_odxlinks(odxlinks)
+        for diag_comm in self.diag_comms:
+            if isinstance(diag_comm, OdxLinkRef):
                 continue
-
-            obj._resolve_odxlinks(odxlinks)
+            diag_comm._resolve_odxlinks(odxlinks)
+        for request in self.requests:
+            request._resolve_odxlinks(odxlinks)
+        for positive_response in self.positive_responses:
+            positive_response._resolve_odxlinks(odxlinks)
+        for negative_response in self.negative_responses:
+            negative_response._resolve_odxlinks(odxlinks)
+        for global_negative_response in self.global_negative_responses:
+            global_negative_response._resolve_odxlinks(odxlinks)
+        for state_chart in self.state_charts:
+            state_chart._resolve_odxlinks(odxlinks)
+        for additional_audience in self.additional_audiences:
+            additional_audience._resolve_odxlinks(odxlinks)
+        for sdg in self.sdgs:
+            sdg._resolve_odxlinks(odxlinks)
+        for parent_ref in self.parent_refs:
+            parent_ref._resolve_odxlinks(odxlinks)
+        for communication_parameter in self.communication_parameters:
+            communication_parameter._resolve_odxlinks(odxlinks)
 
     def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
-        # do reference resolution for the objects that may use short name
-        # references
-        for obj in chain(
-            [self.admin_data],
-                self.company_datas,
-                self.functional_classes,
-            [self.diag_data_dictionary_spec],
-                self.diag_comms,
-                self.requests,
-                self.positive_responses,
-                self.negative_responses,
-                self.global_negative_responses,
-                self.state_charts,
-                self.additional_audiences,
-                self.sdgs,
-                self.parent_refs,
-                self.communication_parameters,
-        ):
-            if obj is None or isinstance(obj, OdxLinkRef):
+        # do short-name reference resolution
+        if self.admin_data is not None:
+            self.admin_data._resolve_snrefs(diag_layer)
+        if self.diag_data_dictionary_spec is not None:
+            self.diag_data_dictionary_spec._resolve_snrefs(diag_layer)
+
+        for company_data in self.company_datas:
+            company_data._resolve_snrefs(diag_layer)
+        for functional_classe in self.functional_classes:
+            functional_classe._resolve_snrefs(diag_layer)
+        for diag_comm in self.diag_comms:
+            if isinstance(diag_comm, OdxLinkRef):
                 continue
-
-            obj._resolve_snrefs(diag_layer)
+            diag_comm._resolve_snrefs(diag_layer)
+        for request in self.requests:
+            request._resolve_snrefs(diag_layer)
+        for positive_response in self.positive_responses:
+            positive_response._resolve_snrefs(diag_layer)
+        for negative_response in self.negative_responses:
+            negative_response._resolve_snrefs(diag_layer)
+        for global_negative_response in self.global_negative_responses:
+            global_negative_response._resolve_snrefs(diag_layer)
+        for state_chart in self.state_charts:
+            state_chart._resolve_snrefs(diag_layer)
+        for additional_audience in self.additional_audiences:
+            additional_audience._resolve_snrefs(diag_layer)
+        for sdg in self.sdgs:
+            sdg._resolve_snrefs(diag_layer)
+        for parent_ref in self.parent_refs:
+            parent_ref._resolve_snrefs(diag_layer)
+        for communication_parameter in self.communication_parameters:
+            communication_parameter._resolve_snrefs(diag_layer)

odxtools/diagnostictroublecode.py

@@ -26,7 +26,7 @@ class DiagnosticTroubleCode(IdentifiableElement):
 
     @property
     def is_temporary(self) -> bool:
-        return self.is_temporary_raw == True
+        return self.is_temporary_raw is True
 
     @staticmethod
     def from_et(et_element: ElementTree.Element,
@@ -69,6 +69,6 @@ class DiagnosticTroubleCode(IdentifiableElement):
         for sdg in self.sdgs:
             sdg._resolve_odxlinks(odxlinks)
 
-    def _resolve_snrefs(self, diag_layer: "DiagLayer"):
+    def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
         for sdg in self.sdgs:
             sdg._resolve_snrefs(diag_layer)

odxtools/diagservice.py

@@ -8,18 +8,21 @@ from .audience import Audience
 from .createsdgs import create_sdgs_from_et
 from .element import IdentifiableElement
 from .exceptions import DecodeError, odxassert, odxrequire
+from .functionalclass import FunctionalClass
 from .message import Message
 from .nameditemlist import NamedItemList
 from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef
+from .odxtypes import ParameterValue
 from .parameters.parameter import Parameter
 from .request import Request
 from .response import Response
 from .specialdatagroup import SpecialDataGroup
+from .state import State
+from .statetransition import StateTransition
 from .utils import dataclass_fields_asdict
 
 if TYPE_CHECKING:
     from .diaglayer import DiagLayer
-    from .endofpdufield import EndOfPduField
 
 
 @dataclass
@@ -96,7 +99,7 @@ class DiagService(IdentifiableElement):
         return self._request
 
     @property
-    def free_parameters(self) -> List[Union[Parameter, "EndOfPduField"]]:  # type: ignore
+    def free_parameters(self) -> List[Parameter]:
         """Return the list of parameters which can be freely specified by
         the user when encoding the service's request.
         """
@@ -112,23 +115,23 @@ class DiagService(IdentifiableElement):
         self.request.print_free_parameters_info()
 
     @property
-    def positive_responses(self) -> Optional[NamedItemList[Response]]:
+    def positive_responses(self) -> NamedItemList[Response]:
         return self._positive_responses
 
     @property
-    def negative_responses(self) -> Optional[NamedItemList[Response]]:
+    def negative_responses(self) -> NamedItemList[Response]:
         return self._negative_responses
 
     @property
-    def functional_classes(self):
+    def functional_classes(self) -> NamedItemList[FunctionalClass]:
         return self._functional_classes
 
     @property
-    def pre_condition_states(self):
+    def pre_condition_states(self) -> NamedItemList[State]:
         return self._pre_condition_states
 
     @property
-    def state_transitions(self):
+    def state_transitions(self) -> NamedItemList[StateTransition]:
         return self._state_transitions
 
     def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
@@ -149,11 +152,11 @@ class DiagService(IdentifiableElement):
             [odxlinks.resolve(x, Response) for x in self.neg_response_refs])
 
         self._functional_classes = NamedItemList(
-            [odxlinks.resolve(fc_id) for fc_id in self.functional_class_refs])
+            [odxlinks.resolve(fc_ref, FunctionalClass) for fc_ref in self.functional_class_refs])
         self._pre_condition_states = NamedItemList(
-            [odxlinks.resolve(st_id) for st_id in self.pre_condition_state_refs])
+            [odxlinks.resolve(st_ref, State) for st_ref in self.pre_condition_state_refs])
         self._state_transitions = NamedItemList(
-            [odxlinks.resolve(stt_id) for stt_id in self.state_transition_refs])
+            [odxlinks.resolve(stt_ref, StateTransition) for stt_ref in self.state_transition_refs])
 
         if self.admin_data:
             self.admin_data._resolve_odxlinks(odxlinks)
@@ -174,31 +177,37 @@ class DiagService(IdentifiableElement):
         for sdg in self.sdgs:
             sdg._resolve_snrefs(diag_layer)
 
-    def decode_message(self, message: bytes) -> Message:
-
-        # Check if message is a request or positive or negative response
-        interpretable_message_types = []
-
-        if (self.request is None or self.positive_responses is None or
-                self.negative_responses is None):
-            raise RuntimeError("References couldn't be resolved or have not been resolved yet."
-                               " Try calling `database.resolve_odxlinks()`.")
+    def decode_message(self, raw_message: bytes) -> Message:
+        request_prefix = b''
+        candidate_coding_objects: List[Union[Request, Response]] = [
+            *self.positive_responses, *self.negative_responses
+        ]
+        if self.request is not None:
+            request_prefix = self.request.coded_const_prefix()
+            candidate_coding_objects.append(self.request)
 
-        for message_type in [self.request, *self.positive_responses, *self.negative_responses]:
-            prefix = message_type.coded_const_prefix(
-                request_prefix=self.request.coded_const_prefix())
-            if all(b == message[i] for (i, b) in enumerate(prefix)):
-                interpretable_message_types.append(message_type)
+        coding_objects: List[Union[Request, Response]] = []
+        for candidate_coding_object in candidate_coding_objects:
+            prefix = candidate_coding_object.coded_const_prefix(request_prefix=request_prefix)
+            if len(raw_message) >= len(prefix) and prefix == raw_message[:len(prefix)]:
+                coding_objects.append(candidate_coding_object)
 
-        if len(interpretable_message_types) != 1:
+        if len(coding_objects) != 1:
             raise DecodeError(
-                f"The service {self.short_name} cannot decode the message {message.hex()}")
-        message_type = interpretable_message_types[0]
-        param_dict = message_type.decode(message)
+                f"The service {self.short_name} cannot decode the message {raw_message.hex()}")
+        coding_object = coding_objects[0]
+        param_dict = coding_object.decode(raw_message)
+        if not isinstance(param_dict, dict):
+            # if this happens, this is probably due to a bug in
+            # coding_object.decode()
+            raise RuntimeError(f"Expected a set of decoded parameters, got {type(param_dict)}")
         return Message(
-            coded_message=message, service=self, structure=message_type, param_dict=param_dict)
+            coded_message=raw_message,
+            service=self,
+            coding_object=coding_object,
+            param_dict=param_dict)
 
-    def encode_request(self, **params):
+    def encode_request(self, **params: ParameterValue) -> bytes:
         """
         Composes an UDS request as list of bytes for this service.
         Parameters:
@@ -209,6 +218,9 @@ class DiagService(IdentifiableElement):
         # make sure that all parameters which are required for
         # encoding are specified (parameters which have a default are
         # optional)
+        if self.request is None:
+            return b''
+
         missing_params = {x.short_name
                           for x in self.request.required_parameters}.difference(params.keys())
         odxassert(not missing_params, f"The parameters {missing_params} are required but missing!")
@@ -219,21 +231,27 @@ class DiagService(IdentifiableElement):
             set(params.keys()).issubset(rq_all_param_names),
             f"Unknown parameters specified for encoding: {params.keys()}, "
             f"known parameters are: {rq_all_param_names}")
-        return self.request.encode(**params)
+        return self.request.encode(coded_request=None, **params)
 
-    def encode_positive_response(self, coded_request, response_index=0, **params):
+    def encode_positive_response(self,
+                                 coded_request: bytes,
+                                 response_index: int = 0,
+                                 **params: ParameterValue) -> bytes:
         # TODO: Should the user decide the positive response or what are the differences?
         return self.positive_responses[response_index].encode(coded_request, **params)
 
-    def encode_negative_response(self, coded_request, response_index=0, **params):
+    def encode_negative_response(self,
+                                 coded_request: bytes,
+                                 response_index: int = 0,
+                                 **params: ParameterValue) -> bytes:
         return self.negative_responses[response_index].encode(coded_request, **params)
 
-    def __call__(self, **params) -> bytes:
+    def __call__(self, **params: ParameterValue) -> bytes:
         """Encode a request."""
         return self.encode_request(**params)
 
     def __hash__(self) -> int:
         return hash(self.odx_id)
 
-    def __eq__(self, o: object) -> bool:
+    def __eq__(self, o: Any) -> bool:
         return isinstance(o, DiagService) and self.odx_id == o.odx_id

odxtools/docrevision.py

@@ -64,7 +64,7 @@ class DocRevision:
     def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
         return {}
 
-    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase):
+    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
         self._team_member: Optional[TeamMember] = None
         if self.team_member_ref is not None:
             self._team_member = odxlinks.resolve(self.team_member_ref, TeamMember)

odxtools/dopbase.py

@@ -1,11 +1,12 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Dict, List, Optional
+from typing import TYPE_CHECKING, Any, Dict, List, Optional, Tuple
 
 from .decodestate import DecodeState
 from .element import IdentifiableElement
 from .encodestate import EncodeState
 from .odxlink import OdxLinkDatabase, OdxLinkId
+from .odxtypes import ParameterValue
 from .specialdatagroup import SpecialDataGroup
 
 if TYPE_CHECKING:
@@ -48,15 +49,25 @@ class DopBase(IdentifiableElement):
         for sdg in self.sdgs:
             sdg._resolve_snrefs(diag_layer)
 
+    def get_static_bit_length(self) -> Optional[int]:
+        return None
+
+    def is_valid_physical_value(self, physical_value: ParameterValue) -> bool:
+        """Determine if a phyical value can be handled by the DOP
+        """
+        raise NotImplementedError
+
     @property
     def is_visible(self) -> bool:
         return self.is_visible_raw in (None, True)
 
-    def convert_physical_to_bytes(self, physical_value, encode_state: EncodeState,
+    def convert_physical_to_bytes(self, physical_value: ParameterValue, encode_state: EncodeState,
                                   bit_position: int) -> bytes:
         """Convert the physical value into bytes."""
         raise NotImplementedError
 
-    def convert_bytes_to_physical(self, decode_state: DecodeState, bit_position: int = 0):
+    def convert_bytes_to_physical(self,
+                                  decode_state: DecodeState,
+                                  bit_position: int = 0) -> Tuple[ParameterValue, int]:
         """Extract the bytes from the PDU and convert them to the physical value."""
         raise NotImplementedError

odxtools/dtcdop.py

@@ -1,13 +1,16 @@
 # SPDX-License-Identifier: MIT
 # from dataclasses import dataclass, field
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Dict, List, Union, cast
+from typing import TYPE_CHECKING, Any, Dict, List, Tuple, Union, cast
 
 from .dataobjectproperty import DataObjectProperty
+from .decodestate import DecodeState
 from .diagnostictroublecode import DiagnosticTroubleCode
+from .encodestate import EncodeState
 from .exceptions import EncodeError, odxassert
 from .nameditemlist import NamedItemList
 from .odxlink import OdxLinkDatabase, OdxLinkId, OdxLinkRef
+from .odxtypes import ParameterValue
 
 if TYPE_CHECKING:
     from .diaglayer import DiagLayer
@@ -28,8 +31,10 @@ class DtcDop(DataObjectProperty):
     def linked_dtc_dops(self) -> NamedItemList["DtcDop"]:
         return self._linked_dtc_dops
 
-    def convert_bytes_to_physical(self, decode_state, bit_position: int = 0):
-        trouble_code, next_byte = super().convert_bytes_to_physical(
+    def convert_bytes_to_physical(self,
+                                  decode_state: DecodeState,
+                                  bit_position: int = 0) -> Tuple[ParameterValue, int]:
+        trouble_code, cursor_position = super().convert_bytes_to_physical(
             decode_state, bit_position=bit_position)
 
         dtcs = [x for x in self.dtcs if x.trouble_code == trouble_code]
@@ -38,7 +43,7 @@ class DtcDop(DataObjectProperty):
 
         if len(dtcs) == 1:
             # we found exactly one described DTC
-            return dtcs[0], next_byte
+            return dtcs[0], cursor_position
 
         # the DTC was not specified. This probably means that the
         # diagnostic description file is incomplete. We do not bail
@@ -57,9 +62,10 @@ class DtcDop(DataObjectProperty):
             sdgs=[],
         )
 
-        return dtc, next_byte
+        return dtc, cursor_position
 
-    def convert_physical_to_bytes(self, physical_value, encode_state, bit_position):
+    def convert_physical_to_bytes(self, physical_value: ParameterValue, encode_state: EncodeState,
+                                  bit_position: int) -> bytes:
         if isinstance(physical_value, DiagnosticTroubleCode):
             trouble_code = physical_value.trouble_code
         elif isinstance(physical_value, int):
@@ -71,7 +77,7 @@ class DtcDop(DataObjectProperty):
             trouble_code = dtc.trouble_code
         else:
             raise EncodeError(f"The DTC-DOP {self.short_name} expected a"
-                              f" DiagnosticTroubleCode but got {physical_value}.")
+                              f" DiagnosticTroubleCode but got {physical_value!r}.")
 
         return super().convert_physical_to_bytes(trouble_code, encode_state, bit_position)
 
@@ -84,7 +90,7 @@ class DtcDop(DataObjectProperty):
 
         return odxlinks
 
-    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase):
+    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
         super()._resolve_odxlinks(odxlinks)
 
         self._dtcs = NamedItemList[DiagnosticTroubleCode]()
@@ -99,7 +105,7 @@ class DtcDop(DataObjectProperty):
         linked_dtc_dops = [odxlinks.resolve(x, DtcDop) for x in self.linked_dtc_dop_refs]
         self._linked_dtc_dops = NamedItemList(linked_dtc_dops)
 
-    def _resolve_snrefs(self, diag_layer: "DiagLayer"):
+    def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
         super()._resolve_snrefs(diag_layer)
 
         for dtc_proxy in self.dtcs_raw:

odxtools/dynamiclengthfield.py

@@ -1,6 +1,6 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Dict, List
+from typing import TYPE_CHECKING, Any, Dict, List, Tuple
 from xml.etree import ElementTree
 
 from .decodestate import DecodeState
@@ -9,7 +9,7 @@ from .encodestate import EncodeState
 from .exceptions import odxrequire
 from .field import Field
 from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
-from .odxtypes import ParameterValueDict
+from .odxtypes import ParameterValue
 from .utils import dataclass_fields_asdict
 
 if TYPE_CHECKING:
@@ -49,11 +49,13 @@ class DynamicLengthField(Field):
 
     def convert_physical_to_bytes(
         self,
-        physical_value: List[ParameterValueDict],
+        physical_value: ParameterValue,
         encode_state: EncodeState,
         bit_position: int = 0,
     ) -> bytes:
         raise NotImplementedError()
 
-    def convert_bytes_to_physical(self, decode_state: DecodeState, bit_position: int = 0):
+    def convert_bytes_to_physical(self,
+                                  decode_state: DecodeState,
+                                  bit_position: int = 0) -> Tuple[ParameterValue, int]:
         raise NotImplementedError()

odxtools/endofpdufield.py

@@ -1,15 +1,15 @@
 # SPDX-License-Identifier: MIT
 from copy import copy
 from dataclasses import dataclass
-from typing import List, Optional
+from typing import List, Optional, Tuple
 from xml.etree import ElementTree
 
 from .decodestate import DecodeState
 from .encodestate import EncodeState
-from .exceptions import odxassert
+from .exceptions import EncodeError, odxassert, odxraise
 from .field import Field
 from .odxlink import OdxDocFragment
-from .odxtypes import ParameterValueDict
+from .odxtypes import ParameterValue
 from .utils import dataclass_fields_asdict
 
 
@@ -42,41 +42,40 @@ class EndOfPduField(Field):
 
     def convert_physical_to_bytes(
         self,
-        physical_value: ParameterValueDict,
+        physical_values: ParameterValue,
         encode_state: EncodeState,
         bit_position: int = 0,
     ) -> bytes:
         odxassert(
             bit_position == 0, "End of PDU field must be byte aligned. "
-            "Is there an error in reading the .odx?")
-        if isinstance(physical_value, dict):
-            # If the value is given as a dict, the End of PDU field behaves like the underlying structure.
-            return self.structure.convert_physical_to_bytes(physical_value, encode_state)
-        else:
-            odxassert(
-                isinstance(physical_value, list),
-                "The value of an End-of-PDU-field must be a list or a dict.")
-            # If the value is given as a list, each list element is a encoded seperately using the structure.
-            coded_rpc = bytes()
-            for value in physical_value:
-                coded_rpc += self.structure.convert_physical_to_bytes(value, encode_state)
-            return coded_rpc
+            "Is there an error in reading the .odx?", EncodeError)
+        if not isinstance(physical_values, list):
+            odxraise(
+                f"Expected a list of values for structure {self.short_name}, "
+                f"got {type(physical_values)}", EncodeError)
+
+        coded_message = b''
+        for value in physical_values:
+            coded_message += self.structure.convert_physical_to_bytes(value, encode_state)
+        return coded_message
 
-    def convert_bytes_to_physical(self, decode_state: DecodeState, bit_position: int = 0):
+    def convert_bytes_to_physical(self,
+                                  decode_state: DecodeState,
+                                  bit_position: int = 0) -> Tuple[ParameterValue, int]:
         decode_state = copy(decode_state)
-        next_byte_position = decode_state.next_byte_position
+        cursor_position = decode_state.cursor_position
         byte_code = decode_state.coded_message
 
         value = []
-        while len(byte_code) > next_byte_position:
+        while len(byte_code) > cursor_position:
             # ATTENTION: the ODX specification is very misleading
             # here: it says that the item is repeated until the end of
             # the PDU, but it means that DOP of the items that are
             # repeated are identical, not their values
-            new_value, next_byte_position = self.structure.convert_bytes_to_physical(
+            new_value, cursor_position = self.structure.convert_bytes_to_physical(
                 decode_state, bit_position=bit_position)
             # Update next byte_position
-            decode_state.next_byte_position = next_byte_position
+            decode_state.cursor_position = cursor_position
             value.append(new_value)
 
-        return value, next_byte_position
+        return value, cursor_position

odxtools/environmentdata.py

@@ -7,6 +7,7 @@ from .basicstructure import BasicStructure
 from .createsdgs import create_sdgs_from_et
 from .element import IdentifiableElement
 from .exceptions import odxrequire
+from .nameditemlist import NamedItemList
 from .odxlink import OdxDocFragment
 from .odxtypes import odxstr_to_bool
 from .parameters.createanyparameter import create_any_parameter_from_et
@@ -19,10 +20,6 @@ class EnvironmentData(BasicStructure):
 
     dtc_values: List[int]
 
-    def __init__(self, *, dtc_values: List[int], **kwargs):
-        super().__init__(**kwargs)
-        self.dtc_values = dtc_values
-
     @staticmethod
     def from_et(et_element: ElementTree.Element,
                 doc_frags: List[OdxDocFragment]) -> "EnvironmentData":
@@ -44,7 +41,7 @@ class EnvironmentData(BasicStructure):
         return EnvironmentData(
             sdgs=sdgs,
             is_visible_raw=is_visible_raw,
-            parameters=parameters,
+            parameters=NamedItemList(parameters),
             byte_size=byte_size,
             dtc_values=dtc_values,
             **kwargs)