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

odxtools/specialdatagroup.py

@@ -1,22 +1,20 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Dict, List, Optional, Union
+from typing import Any, Dict, List, Optional, Union
 from xml.etree import ElementTree
 
 from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef
+from .snrefcontext import SnRefContext
 from .specialdata import SpecialData
 from .specialdatagroupcaption import SpecialDataGroupCaption
 
-if TYPE_CHECKING:
-    from .diaglayer import DiagLayer
-
 
 @dataclass
 class SpecialDataGroup:
     sdg_caption: Optional[SpecialDataGroupCaption]
     sdg_caption_ref: Optional[OdxLinkRef]
-    semantic_info: Optional[str]  # the "SI" attribute
     values: List[Union["SpecialDataGroup", SpecialData]]
+    semantic_info: Optional[str]  # the "SI" attribute
 
     @staticmethod
     def from_et(et_element: ElementTree.Element,
@@ -53,7 +51,7 @@ class SpecialDataGroup:
     def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
         result = {}
 
-        if self.sdg_caption is not None:
+        if self.sdg_caption_ref is None and self.sdg_caption is not None:
             result.update(self.sdg_caption._build_odxlinks())
 
         for val in self.values:
@@ -72,11 +70,11 @@ class SpecialDataGroup:
         for val in self.values:
             val._resolve_odxlinks(odxlinks)
 
-    def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
         # resolve the SNREFs of the caption, but only if the caption
         # was specified by value, not by reference
         if self.sdg_caption is not None and self.sdg_caption_ref is None:
-            self.sdg_caption._resolve_snrefs(diag_layer)
+            self.sdg_caption._resolve_snrefs(context)
 
         for val in self.values:
-            val._resolve_snrefs(diag_layer)
+            val._resolve_snrefs(context)

odxtools/specialdatagroupcaption.py

@@ -1,16 +1,13 @@
 # SPDX-License-Identifier: MIT
-# import warnings
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Dict, List
+from typing import Any, Dict, List
 from xml.etree import ElementTree
 
 from .element import IdentifiableElement
 from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
+from .snrefcontext import SnRefContext
 from .utils import dataclass_fields_asdict
 
-if TYPE_CHECKING:
-    from .diaglayer import DiagLayer
-
 
 @dataclass
 class SpecialDataGroupCaption(IdentifiableElement):
@@ -32,5 +29,5 @@ class SpecialDataGroupCaption(IdentifiableElement):
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
         pass
 
-    def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
         pass

odxtools/standardlengthtype.py

@@ -1,12 +1,17 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import Optional
+from typing import List, Literal, Optional
+from xml.etree import ElementTree
+
+from typing_extensions import override
 
 from .decodestate import DecodeState
 from .diagcodedtype import DctType, DiagCodedType
 from .encodestate import EncodeState
-from .exceptions import odxassert, odxraise
-from .odxtypes import AtomicOdxType, DataType
+from .exceptions import odxassert, odxraise, odxrequire
+from .odxlink import OdxDocFragment
+from .odxtypes import AtomicOdxType, DataType, odxstr_to_bool
+from .utils import dataclass_fields_asdict
 
 
 @dataclass
@@ -16,10 +21,36 @@ class StandardLengthType(DiagCodedType):
     bit_mask: Optional[int]
     is_condensed_raw: Optional[bool]
 
+    @staticmethod
+    @override
+    def from_et(et_element: ElementTree.Element,
+                doc_frags: List[OdxDocFragment]) -> "StandardLengthType":
+        kwargs = dataclass_fields_asdict(DiagCodedType.from_et(et_element, doc_frags))
+
+        bit_length = int(odxrequire(et_element.findtext("BIT-LENGTH")))
+        bit_mask = None
+        if (bit_mask_str := et_element.findtext("BIT-MASK")) is not None:
+            # The XSD uses the type xsd:hexBinary
+            # xsd:hexBinary allows for leading/trailing whitespace, empty strings, and it only allows an even
+            # number of hex digits, while some of the examples shown in the  ODX specification exhibit an
+            # odd number of hex digits.
+            # This causes a validation paradox, so we try to be flexible
+            bit_mask_str = bit_mask_str.strip()
+            if len(bit_mask_str):
+                bit_mask = int(bit_mask_str, 16)
+        is_condensed_raw = odxstr_to_bool(et_element.get("IS-CONDENSED"))
+
+        return StandardLengthType(
+            bit_length=bit_length, bit_mask=bit_mask, is_condensed_raw=is_condensed_raw, **kwargs)
+
     @property
     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 +59,46 @@ 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
+
+        max_value = (1 << (sz * 8)) - 1
+        bit_mask = self.bit_mask & max_value
+
+        return bit_mask.to_bytes(sz, endianness)
+
     def __apply_mask(self, internal_value: AtomicOdxType) -> AtomicOdxType:
         if self.bit_mask is None:
             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 +112,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/state.py

@@ -1,15 +1,13 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Dict, List
+from typing import Any, Dict, List
 from xml.etree import ElementTree
 
 from .element import IdentifiableElement
 from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
+from .snrefcontext import SnRefContext
 from .utils import dataclass_fields_asdict
 
-if TYPE_CHECKING:
-    from .diaglayer import DiagLayer
-
 
 @dataclass
 class State(IdentifiableElement):
@@ -29,5 +27,5 @@ class State(IdentifiableElement):
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
         pass
 
-    def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
         pass

odxtools/statechart.py

@@ -1,19 +1,17 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Dict, List
+from typing import Any, Dict, List
 from xml.etree import ElementTree
 
 from .element import IdentifiableElement
 from .exceptions import odxrequire
 from .nameditemlist import NamedItemList
-from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
+from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, resolve_snref
+from .snrefcontext import SnRefContext
 from .state import State
 from .statetransition import StateTransition
 from .utils import dataclass_fields_asdict
 
-if TYPE_CHECKING:
-    from .diaglayer import DiagLayer
-
 
 @dataclass
 class StateChart(IdentifiableElement):
@@ -68,25 +66,21 @@ class StateChart(IdentifiableElement):
         for st in self.states:
             st._resolve_odxlinks(odxlinks)
 
-        # For now, we assume that the start state short name ref
-        # points to a state local to the state chart. TODO: The XML
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
+        context.state_chart = self
+
+        # For now, we assume that the start state short name reference
+        # points to a local state of the state chart. TODO: The XSD
         # allows to define state charts without any states, yet the
         # start state SNREF is mandatory. Is this a gap in the spec or
         # does it allow "foreign" start states? If the latter, what
         # does that mean?
-        self._start_state: State
-        for st in self.states:
-            if st.short_name == self.start_state_snref:
-                self._start_state = st
-                break
+        self._start_state = resolve_snref(self.start_state_snref, self.states, State)
 
-    def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
         for st in self.states:
-            st._resolve_snrefs(diag_layer)
+            st._resolve_snrefs(context)
 
         for strans in self.state_transitions:
-            # note that the signature of the state transition's
-            # _resolve_snrefs() method is non-standard as the
-            # namespace of these SNREFs is the state chart, not the
-            # whole diag layer...
-            strans._resolve_snrefs(diag_layer, states=self.states)
+            strans._resolve_snrefs(context)
+
+        context.state_chart = None

odxtools/statetransition.py

@@ -1,17 +1,15 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Dict, Iterable, List
+from typing import Any, Dict, List
 from xml.etree import ElementTree
 
 from .element import IdentifiableElement
 from .exceptions import odxrequire
-from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
+from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, resolve_snref
+from .snrefcontext import SnRefContext
 from .state import State
 from .utils import dataclass_fields_asdict
 
-if TYPE_CHECKING:
-    from .diaglayer import DiagLayer
-
 
 @dataclass
 class StateTransition(IdentifiableElement):
@@ -50,15 +48,7 @@ class StateTransition(IdentifiableElement):
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
         pass
 
-    # note that the signature of this method is non-standard because
-    # the namespace of these SNREFs is the corresponding state
-    # chart. To mitigate this a bit, the non-standard parameters are
-    # keyword-only...
-    def _resolve_snrefs(self, diag_layer: "DiagLayer", *, states: Iterable[State]) -> None:
-        self._source_state: State
-        self._target_state: State
-        for st in states:
-            if st.short_name == self.source_snref:
-                self._source_state = st
-            if st.short_name == self.target_snref:
-                self._target_state = st
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
+        states = odxrequire(context.state_chart).states
+        self._source_state = resolve_snref(self.source_snref, states, State)
+        self._target_state = resolve_snref(self.target_snref, states, State)

odxtools/staticfield.py

@@ -1,6 +1,6 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Dict, List
+from typing import Any, Dict, List, Sequence
 from xml.etree import ElementTree
 
 from typing_extensions import override
@@ -11,11 +11,9 @@ from .exceptions import odxassert, odxraise, odxrequire
 from .field import Field
 from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
 from .odxtypes import ParameterValue
+from .snrefcontext import SnRefContext
 from .utils import dataclass_fields_asdict
 
-if TYPE_CHECKING:
-    from .diaglayer import DiagLayer
-
 
 @dataclass
 class StaticField(Field):
@@ -44,40 +42,43 @@ class StaticField(Field):
         super()._resolve_odxlinks(odxlinks)
 
     @override
-    def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
-        super()._resolve_snrefs(diag_layer)
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
+        super()._resolve_snrefs(context)
 
     @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:
+                          Sequence) 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:
+        orig_is_end_of_pdu = encode_state.is_end_of_pdu
+        encode_state.is_end_of_pdu = False
+        for i, val in enumerate(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 i == len(physical_value) - 1:
+                encode_state.is_end_of_pdu = orig_is_end_of_pdu
 
-            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:
-                # add some padding bytes
-                data = data.ljust(self.item_byte_size, b'\x00')
+            pos_before = encode_state.cursor_byte_position
+            self.structure.encode_into_pdu(val, encode_state)
+            pos_after = encode_state.cursor_byte_position
 
-            result += data
+            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
+                encode_state.emplace_bytes(b'\x00' * (self.item_byte_size -
+                                                      (pos_after - pos_before)))
 
-        return result
+        encode_state.is_end_of_pdu = orig_is_end_of_pdu
 
     @override
     def decode_from_pdu(self, decode_state: DecodeState) -> ParameterValue:
@@ -85,6 +86,9 @@ class StaticField(Field):
         odxassert(decode_state.cursor_bit_position == 0,
                   "No bit position can be specified for static length fields!")
 
+        orig_origin = decode_state.origin_byte_position
+        decode_state.origin_byte_position = decode_state.cursor_byte_position
+
         result: List[ParameterValue] = []
         for _ in range(self.fixed_number_of_items):
             orig_cursor = decode_state.cursor_byte_position
@@ -98,4 +102,6 @@ class StaticField(Field):
 
             decode_state.cursor_byte_position = orig_cursor + self.item_byte_size
 
+        decode_state.origin_byte_position = orig_origin
+
         return result