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

odxtools/dataobjectproperty.py

@@ -1,6 +1,6 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Dict, List, Optional, cast
+from typing import Any, Dict, List, Optional, cast
 from xml.etree import ElementTree
 
 from .compumethods.compumethod import CompuMethod
@@ -10,17 +10,15 @@ from .decodestate import DecodeState
 from .diagcodedtype import DiagCodedType
 from .dopbase import DopBase
 from .encodestate import EncodeState
-from .exceptions import DecodeError, EncodeError, odxassert, odxrequire
+from .exceptions import DecodeError, EncodeError, odxraise, odxrequire
 from .internalconstr import InternalConstr
 from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef
 from .odxtypes import AtomicOdxType, ParameterValue
 from .physicaltype import PhysicalType
+from .snrefcontext import SnRefContext
 from .unit import Unit
 from .utils import dataclass_fields_asdict
 
-if TYPE_CHECKING:
-    from .diaglayer import DiagLayer
-
 
 @dataclass
 class DataObjectProperty(DopBase):
@@ -59,20 +57,20 @@ class DataObjectProperty(DopBase):
         compu_method = create_any_compu_method_from_et(
             odxrequire(et_element.find("COMPU-METHOD")),
             doc_frags,
-            diag_coded_type.base_data_type,
-            physical_type.base_data_type,
+            internal_type=diag_coded_type.base_data_type,
+            physical_type=physical_type.base_data_type,
         )
         unit_ref = OdxLinkRef.from_et(et_element.find("UNIT-REF"), doc_frags)
 
         internal_constr = None
         if (internal_constr_elem := et_element.find("INTERNAL-CONSTR")) is not None:
-            internal_constr = InternalConstr.from_et(
-                internal_constr_elem, internal_type=diag_coded_type.base_data_type)
+            internal_constr = InternalConstr.constr_from_et(
+                internal_constr_elem, doc_frags, value_type=diag_coded_type.base_data_type)
 
         physical_constr = None
         if (physical_constr_elem := et_element.find("PHYS-CONSTR")) is not None:
-            physical_constr = InternalConstr.from_et(
-                physical_constr_elem, internal_type=physical_type.base_data_type)
+            physical_constr = InternalConstr.constr_from_et(
+                physical_constr_elem, doc_frags, value_type=physical_type.base_data_type)
 
         return DataObjectProperty(
             diag_coded_type=diag_coded_type,
@@ -86,6 +84,7 @@ class DataObjectProperty(DopBase):
     def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
         result = super()._build_odxlinks()
         result.update(self.diag_coded_type._build_odxlinks())
+        result.update(self.compu_method._build_odxlinks())
         return result
 
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
@@ -93,15 +92,17 @@ class DataObjectProperty(DopBase):
         super()._resolve_odxlinks(odxlinks)
 
         self.diag_coded_type._resolve_odxlinks(odxlinks)
+        self.compu_method._resolve_odxlinks(odxlinks)
 
         self._unit: Optional[Unit] = None
         if self.unit_ref:
             self._unit = odxlinks.resolve(self.unit_ref, Unit)
 
-    def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
-        super()._resolve_snrefs(diag_layer)
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
+        super()._resolve_snrefs(context)
 
-        self.diag_coded_type._resolve_snrefs(diag_layer)
+        self.diag_coded_type._resolve_snrefs(context)
+        self.compu_method._resolve_snrefs(context)
 
     @property
     def unit(self) -> Optional[Unit]:
@@ -110,28 +111,20 @@ class DataObjectProperty(DopBase):
     def get_static_bit_length(self) -> Optional[int]:
         return self.diag_coded_type.get_static_bit_length()
 
-    def convert_physical_to_internal(self, physical_value: Any) -> Any:
-        """
-        Convert a physical representation of a parameter to its internal counterpart
-        """
-        odxassert(
-            self.physical_type.base_data_type.isinstance(physical_value),
-            f"Expected {self.physical_type.base_data_type.value}, got {type(physical_value)}")
-
-        return self.compu_method.convert_physical_to_internal(physical_value)
-
-    def convert_physical_to_bytes(self, physical_value: Any, encode_state: EncodeState,
-                                  bit_position: int) -> bytes:
+    def encode_into_pdu(self, physical_value: ParameterValue, encode_state: EncodeState) -> None:
         """
         Convert a physical representation of a parameter to a string bytes that can be send over the wire
         """
         if not self.is_valid_physical_value(physical_value):
-            raise EncodeError(f"The value {repr(physical_value)} of type {type(physical_value)}"
-                              f" is not a valid.")
-
-        internal_val = self.convert_physical_to_internal(physical_value)
-        return self.diag_coded_type.convert_internal_to_bytes(
-            internal_val, encode_state, bit_position=bit_position)
+            raise EncodeError(
+                f"The value {repr(physical_value)} of type {type(physical_value).__name__}"
+                f" is not a valid.")
+
+        if not isinstance(physical_value, (int, float, str, bytes, bytearray)):
+            odxraise(f"Invalid type '{type(physical_value).__name__}' for physical value. "
+                     f"(Expect atomic type!)")
+        internal_value = self.compu_method.convert_physical_to_internal(physical_value)
+        self.diag_coded_type.encode_into_pdu(internal_value, encode_state)
 
     def decode_from_pdu(self, decode_state: DecodeState) -> ParameterValue:
         """

odxtools/decodestate.py

@@ -1,11 +1,11 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass, field
-from typing import TYPE_CHECKING, Dict
+from typing import TYPE_CHECKING, Dict, List, Optional, Tuple, cast
 
 import odxtools.exceptions as exceptions
 
 from .exceptions import DecodeError
-from .odxtypes import AtomicOdxType, DataType
+from .odxtypes import AtomicOdxType, DataType, ParameterValue
 
 try:
     import bitstruct.c as bitstruct
@@ -13,20 +13,9 @@ except ImportError:
     import bitstruct
 
 if TYPE_CHECKING:
+    from .parameters.parameter import Parameter
     from .tablerow import TableRow
 
-# format specifiers for the data type using the bitstruct module
-ODX_TYPE_TO_FORMAT_LETTER = {
-    DataType.A_INT32: "s",
-    DataType.A_UINT32: "u",
-    DataType.A_FLOAT32: "f",
-    DataType.A_FLOAT64: "f",
-    DataType.A_BYTEFIELD: "r",
-    DataType.A_UNICODE2STRING: "r",  # UTF-16 strings must be converted explicitly
-    DataType.A_ASCIISTRING: "r",
-    DataType.A_UTF8STRING: "r",
-}
-
 
 @dataclass
 class DecodeState:
@@ -58,6 +47,11 @@ class DecodeState:
     #: values of the table key parameters decoded so far
     table_keys: Dict[str, "TableRow"] = field(default_factory=dict)
 
+    #: List of parameters that have been decoded so far. The journal
+    #: is used by some types of parameters which depend on the values of
+    #: other parameters; i.e., environment data description parameters
+    journal: List[Tuple["Parameter", Optional[ParameterValue]]] = field(default_factory=list)
+
     def extract_atomic_value(
         self,
         bit_length: int,
@@ -72,7 +66,7 @@ class DecodeState:
         """
         # If the bit length is zero, return "empty" values of each type
         if bit_length == 0:
-            return base_data_type.as_python_type()()
+            return base_data_type.python_type()
 
         byte_length = (bit_length + self.cursor_bit_position + 7) // 8
         if self.cursor_byte_position + byte_length > len(self.coded_message):
@@ -94,12 +88,13 @@ class DecodeState:
 
         padding = (8 - (bit_length + self.cursor_bit_position) % 8) % 8
         internal_value, = bitstruct.unpack_from(
-            f"{ODX_TYPE_TO_FORMAT_LETTER[base_data_type]}{bit_length}",
+            f"{base_data_type.bitstruct_format_letter}{bit_length}",
             extracted_bytes,
             offset=padding)
 
         text_errors = 'strict' if exceptions.strict_mode else 'replace'
         if base_data_type == DataType.A_ASCIISTRING:
+            assert isinstance(internal_value, (bytes, bytearray))
             # The spec says ASCII, meaning only byte values 0-127.
             # But in practice, vendors use iso-8859-1, aka latin-1
             # reason being iso-8859-1 never fails since it has a valid
@@ -107,9 +102,11 @@ class DecodeState:
             text_encoding = 'iso-8859-1'
             internal_value = internal_value.decode(encoding=text_encoding, errors=text_errors)
         elif base_data_type == DataType.A_UTF8STRING:
+            assert isinstance(internal_value, (bytes, bytearray))
             text_encoding = "utf-8"
             internal_value = internal_value.decode(encoding=text_encoding, errors=text_errors)
         elif base_data_type == DataType.A_UNICODE2STRING:
+            assert isinstance(internal_value, (bytes, bytearray))
             # For UTF-16, we need to manually decode the extracted
             # bytes to a string
             text_encoding = "utf-16-be" if is_highlow_byte_order else "utf-16-le"
@@ -118,4 +115,4 @@ class DecodeState:
         self.cursor_byte_position += byte_length
         self.cursor_bit_position = 0
 
-        return internal_value
+        return cast(AtomicOdxType, internal_value)

odxtools/description.py

@@ -0,0 +1,47 @@
+from dataclasses import dataclass
+from typing import List, Optional
+from xml.etree import ElementTree
+
+from .exceptions import odxrequire
+from .odxlink import OdxDocFragment
+
+
+@dataclass
+class Description:
+    text: str
+    external_docs: List[str]
+    text_identifier: Optional[str]
+
+    @staticmethod
+    def from_et(et_element: Optional[ElementTree.Element],
+                doc_frags: List[OdxDocFragment]) -> Optional["Description"]:
+        if et_element is None:
+            return None
+
+        # Extract the contents of the tag as a XHTML string.
+        raw_string = et_element.text or ""
+        for e in et_element:
+            if e.tag == "EXTERNAL-DOCS":
+                break
+            raw_string += ElementTree.tostring(e, encoding="unicode")
+
+        # remove white spaces at the beginning and at the end of all
+        # extracted lines
+        stripped_lines = [x.strip() for x in raw_string.split("\n")]
+
+        text = "\n".join(stripped_lines).strip()
+
+        text_identifier = et_element.get("TI")
+
+        external_docs = \
+            [
+                odxrequire(ed.get("HREF")) for ed in et_element.iterfind("EXTERNAL-DOCS/EXTERNAL-DOC")
+            ]
+        return Description(text=text, text_identifier=text_identifier, external_docs=external_docs)
+
+    @staticmethod
+    def from_string(text: str) -> "Description":
+        return Description(text=text, external_docs=[], text_identifier=None)
+
+    def __str__(self) -> str:
+        return self.text

odxtools/determinenumberofitems.py

@@ -1,13 +1,12 @@
+# SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Dict, List, Optional
+from typing import Any, Dict, List, Optional
 from xml.etree import ElementTree
 
 from .dataobjectproperty import DataObjectProperty
 from .exceptions import odxrequire
 from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef
-
-if TYPE_CHECKING:
-    from ..diaglayer import DiagLayer
+from .snrefcontext import SnRefContext
 
 
 @dataclass
@@ -39,7 +38,7 @@ class DetermineNumberOfItems:
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
         self._dop = odxlinks.resolve(self.dop_ref, DataObjectProperty)
 
-    def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
         pass
 
     @property

odxtools/diagcodedtype.py

@@ -1,21 +1,14 @@
 # SPDX-License-Identifier: MIT
-import abc
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Dict, Literal, Optional, Union
+from typing import Any, Dict, List, Literal, Optional, Union, cast
+from xml.etree import ElementTree
 
-from .decodestate import ODX_TYPE_TO_FORMAT_LETTER, DecodeState
+from .decodestate import DecodeState
 from .encodestate import EncodeState
-from .exceptions import EncodeError, odxassert, odxraise
-from .odxlink import OdxLinkDatabase, OdxLinkId
-from .odxtypes import AtomicOdxType, DataType
-
-try:
-    import bitstruct.c as bitstruct
-except ImportError:
-    import bitstruct
-
-if TYPE_CHECKING:
-    from .diaglayer import DiagLayer
+from .exceptions import odxassert, odxraise, odxrequire
+from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
+from .odxtypes import AtomicOdxType, DataType, odxstr_to_bool
+from .snrefcontext import SnRefContext
 
 # Allowed diag-coded types
 DctType = Literal[
@@ -27,12 +20,30 @@ DctType = Literal[
 
 
 @dataclass
-class DiagCodedType(abc.ABC):
+class DiagCodedType:
 
     base_data_type: DataType
     base_type_encoding: Optional[str]
     is_highlow_byte_order_raw: Optional[bool]
 
+    @staticmethod
+    def from_et(et_element: ElementTree.Element,
+                doc_frags: List[OdxDocFragment]) -> "DiagCodedType":
+        base_data_type_str = odxrequire(et_element.get("BASE-DATA-TYPE"))
+        try:
+            base_data_type = DataType(base_data_type_str)
+        except ValueError:
+            odxraise(f"Unknown base data type {base_data_type_str}")
+            base_data_type = cast(DataType, None)
+
+        base_type_encoding = et_element.get("BASE-TYPE-ENCODING")
+        is_highlow_byte_order_raw = odxstr_to_bool(et_element.get("IS-HIGHLOW-BYTE-ORDER"))
+
+        return DiagCodedType(
+            base_data_type=base_data_type,
+            base_type_encoding=base_type_encoding,
+            is_highlow_byte_order_raw=is_highlow_byte_order_raw)
+
     def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:  # noqa: B027
         return {}
 
@@ -40,7 +51,7 @@ class DiagCodedType(abc.ABC):
         """Recursively resolve any odxlinks references"""
         pass
 
-    def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:  # noqa: B027
+    def _resolve_snrefs(self, context: SnRefContext) -> None:  # noqa: B027
         """Recursively resolve any short-name references"""
         pass
 
@@ -48,100 +59,20 @@ class DiagCodedType(abc.ABC):
         return None
 
     @property
-    @abc.abstractmethod
     def dct_type(self) -> DctType:
-        pass
+        odxraise(f"Class {type(self).__name__} does not override required method "
+                 f"dct_type()", NotImplementedError)
+        return cast(DctType, None)
 
     @property
     def is_highlow_byte_order(self) -> bool:
         return self.is_highlow_byte_order_raw in [None, True]
 
-    @staticmethod
-    def _encode_internal_value(
-        internal_value: AtomicOdxType,
-        bit_position: int,
-        bit_length: int,
-        base_data_type: DataType,
-        is_highlow_byte_order: bool,
-    ) -> bytes:
-        """Convert the internal_value to bytes."""
-        # Check that bytes and strings actually fit into the bit length
-        if base_data_type == DataType.A_BYTEFIELD:
-            if isinstance(internal_value, bytearray):
-                internal_value = bytes(internal_value)
-            if not isinstance(internal_value, bytes):
-                odxraise()
-            if 8 * len(internal_value) > bit_length:
-                raise EncodeError(f"The bytefield {internal_value.hex()} is too large "
-                                  f"({len(internal_value)} bytes)."
-                                  f" The maximum length is {bit_length//8}.")
-        if base_data_type == DataType.A_ASCIISTRING:
-            if not isinstance(internal_value, str):
-                odxraise()
-
-            # The spec says ASCII, meaning only byte values 0-127.
-            # But in practice, vendors use iso-8859-1, aka latin-1
-            # reason being iso-8859-1 never fails since it has a valid
-            # character mapping for every possible byte sequence.
-            internal_value = internal_value.encode("iso-8859-1")
-
-            if 8 * len(internal_value) > bit_length:
-                raise EncodeError(f"The string {repr(internal_value)} is too large."
-                                  f" The maximum number of characters is {bit_length//8}.")
-        elif base_data_type == DataType.A_UTF8STRING:
-            if not isinstance(internal_value, str):
-                odxraise()
-
-            internal_value = internal_value.encode("utf-8")
-
-            if 8 * len(internal_value) > bit_length:
-                raise EncodeError(f"The string {repr(internal_value)} is too large."
-                                  f" The maximum number of bytes is {bit_length//8}.")
-
-        elif base_data_type == DataType.A_UNICODE2STRING:
-            if not isinstance(internal_value, str):
-                odxraise()
-
-            text_encoding = "utf-16-be" if is_highlow_byte_order else "utf-16-le"
-            internal_value = internal_value.encode(text_encoding)
-
-            if 8 * len(internal_value) > bit_length:
-                raise EncodeError(f"The string {repr(internal_value)} is too large."
-                                  f" The maximum number of characters is {bit_length//16}.")
-
-        # If the bit length is zero, return empty bytes
-        if bit_length == 0:
-            if (base_data_type in [
-                    DataType.A_INT32, DataType.A_UINT32, DataType.A_FLOAT32, DataType.A_FLOAT64
-            ] and base_data_type != 0):
-                raise EncodeError(
-                    f"The number {repr(internal_value)} cannot be encoded into {bit_length} bits.")
-            return b''
-
-        char = ODX_TYPE_TO_FORMAT_LETTER[base_data_type]
-        padding = (8 - ((bit_length + bit_position) % 8)) % 8
-        odxassert((0 <= padding and padding < 8 and (padding + bit_length + bit_position) % 8 == 0),
-                  f"Incorrect padding {padding}")
-        left_pad = f"p{padding}" if padding > 0 else ""
-
-        # actually encode the value
-        coded = bitstruct.pack(f"{left_pad}{char}{bit_length}", internal_value)
-
-        # apply byte order for numeric objects
-        if not is_highlow_byte_order and base_data_type in [
-                DataType.A_INT32,
-                DataType.A_UINT32,
-                DataType.A_FLOAT32,
-                DataType.A_FLOAT64,
-        ]:
-            coded = coded[::-1]
-
-        return coded
-
     def _minimal_byte_length_of(self, internal_value: Union[bytes, str]) -> int:
         """Helper method to get the minimal byte length.
         (needed for LeadingLength- and MinMaxLengthType)
         """
+        byte_length: int = -1
         # A_BYTEFIELD, A_ASCIISTRING, A_UNICODE2STRING, A_UTF8STRING
         if self.base_data_type == DataType.A_BYTEFIELD:
             byte_length = len(internal_value)
@@ -159,11 +90,10 @@ class DiagCodedType(abc.ABC):
             odxassert(
                 byte_length % 2 == 0, f"The bit length of A_UNICODE2STRING must"
                 f" be a multiple of 16 but is {8*byte_length}")
+
         return byte_length
 
-    @abc.abstractmethod
-    def convert_internal_to_bytes(self, internal_value: AtomicOdxType, encode_state: EncodeState,
-                                  bit_position: int) -> bytes:
+    def encode_into_pdu(self, internal_value: AtomicOdxType, encode_state: EncodeState) -> None:
         """Encode the internal value.
 
         Parameters
@@ -176,9 +106,9 @@ class DiagCodedType(abc.ABC):
             mapping from ID (of the length key) to bit length
             (only needed for ParamLengthInfoType)
         """
-        pass
+        raise NotImplementedError(
+            f".encode_into_pdu() is not implemented by the class {type(self).__name__}")
 
-    @abc.abstractmethod
     def decode_from_pdu(self, decode_state: DecodeState) -> AtomicOdxType:
         """Decode the parameter value from the coded message.
 
@@ -194,4 +124,5 @@ class DiagCodedType(abc.ABC):
         int
             the next byte position after the extracted parameter
         """
-        pass
+        raise NotImplementedError(
+            f".decode_from_pdu() is not implemented by the class {type(self).__name__}")

odxtools/diagcomm.py

@@ -6,20 +6,20 @@ from xml.etree import ElementTree
 
 from .admindata import AdminData
 from .audience import Audience
-from .createsdgs import create_sdgs_from_et
 from .element import IdentifiableElement
 from .exceptions import odxraise, odxrequire
 from .functionalclass import FunctionalClass
 from .nameditemlist import NamedItemList
-from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef
+from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef, resolve_snref
 from .odxtypes import odxstr_to_bool
+from .snrefcontext import SnRefContext
 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 .diaglayers.protocol import Protocol
 
 
 class DiagClassType(Enum):
@@ -76,7 +76,9 @@ class DiagComm(IdentifiableElement):
         kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, doc_frags))
 
         admin_data = AdminData.from_et(et_element.find("ADMIN-DATA"), doc_frags)
-        sdgs = create_sdgs_from_et(et_element.find("SDGS"), doc_frags)
+        sdgs = [
+            SpecialDataGroup.from_et(sdge, doc_frags) for sdge in et_element.iterfind("SDGS/SDG")
+        ]
 
         functional_class_refs = [
             odxrequire(OdxLinkRef.from_et(el, doc_frags))
@@ -141,7 +143,7 @@ class DiagComm(IdentifiableElement):
         return self._functional_classes
 
     @property
-    def protocols(self) -> NamedItemList["DiagLayer"]:
+    def protocols(self) -> NamedItemList["Protocol"]:
         return self._protocols
 
     @property
@@ -201,15 +203,25 @@ class DiagComm(IdentifiableElement):
         self._state_transitions = NamedItemList(
             [odxlinks.resolve(stt_ref, StateTransition) for stt_ref in self.state_transition_refs])
 
-    def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
         if self.admin_data:
-            self.admin_data._resolve_snrefs(diag_layer)
+            self.admin_data._resolve_snrefs(context)
 
         if self.audience:
-            self.audience._resolve_snrefs(diag_layer)
+            self.audience._resolve_snrefs(context)
 
         for sdg in self.sdgs:
-            sdg._resolve_snrefs(diag_layer)
-
-        self._protocols = NamedItemList(
-            [diag_layer.protocols[prot_snref] for prot_snref in self.protocol_snrefs])
+            sdg._resolve_snrefs(context)
+
+        if TYPE_CHECKING:
+            diag_layer = odxrequire(context.diag_layer)
+            self._protocols = NamedItemList([
+                resolve_snref(prot_snref, getattr(diag_layer, "protocols", []), Protocol)
+                for prot_snref in self.protocol_snrefs
+            ])
+        else:
+            diag_layer = odxrequire(context.diag_layer)
+            self._protocols = NamedItemList([
+                resolve_snref(prot_snref, getattr(diag_layer, "protocols", []))
+                for prot_snref in self.protocol_snrefs
+            ])