odxtools 9.2.0__py3-none-any.whl → 9.4.0__py3-none-any.whl

odxtools/leadinglengthinfotype.py

@@ -72,6 +72,7 @@ class LeadingLengthInfoType(DiagCodedType):
             used_mask=None,
             bit_length=self.bit_length,
             base_data_type=DataType.A_UINT32,
+            base_type_encoding=None,
             is_highlow_byte_order=self.is_highlow_byte_order,
         )
 
@@ -80,6 +81,7 @@ class LeadingLengthInfoType(DiagCodedType):
             used_mask=None,
             bit_length=8 * byte_length,
             base_data_type=self.base_data_type,
+            base_type_encoding=None,
             is_highlow_byte_order=self.is_highlow_byte_order,
         )
 
@@ -90,6 +92,7 @@ class LeadingLengthInfoType(DiagCodedType):
         byte_length = decode_state.extract_atomic_value(
             bit_length=self.bit_length,
             base_data_type=DataType.A_UINT32,  # length is an integer
+            base_type_encoding=None,
             is_highlow_byte_order=self.is_highlow_byte_order,
         )
 
@@ -102,6 +105,7 @@ class LeadingLengthInfoType(DiagCodedType):
         value = decode_state.extract_atomic_value(
             bit_length=8 * byte_length,
             base_data_type=self.base_data_type,
+            base_type_encoding=None,
             is_highlow_byte_order=self.is_highlow_byte_order,
         )
 

odxtools/minmaxlengthtype.py

@@ -1,6 +1,7 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import List, Optional
+from enum import Enum
+from typing import List, Optional, cast
 from xml.etree import ElementTree
 
 from typing_extensions import override
@@ -8,17 +9,24 @@ from typing_extensions import override
 from .decodestate import DecodeState
 from .diagcodedtype import DctType, DiagCodedType
 from .encodestate import EncodeState
+from .encoding import get_string_encoding
 from .exceptions import DecodeError, EncodeError, odxassert, odxraise, odxrequire
 from .odxlink import OdxDocFragment
 from .odxtypes import AtomicOdxType, DataType
 from .utils import dataclass_fields_asdict
 
 
+class Termination(Enum):
+    END_OF_PDU = "END-OF-PDU"
+    ZERO = "ZERO"
+    HEX_FF = "HEX-FF"
+
+
 @dataclass
 class MinMaxLengthType(DiagCodedType):
     min_length: int
     max_length: Optional[int]
-    termination: str
+    termination: Termination
 
     @property
     def dct_type(self) -> DctType:
@@ -34,7 +42,13 @@ class MinMaxLengthType(DiagCodedType):
         max_length = None
         if et_element.find("MAX-LENGTH") is not None:
             max_length = int(odxrequire(et_element.findtext("MAX-LENGTH")))
-        termination = odxrequire(et_element.get("TERMINATION"))
+
+        termination_str = odxrequire(et_element.get("TERMINATION"))
+        try:
+            termination = Termination(termination_str)
+        except ValueError:
+            termination = cast(Termination, None)
+            odxraise(f"Encountered unknown termination type '{termination_str}'")
 
         return MinMaxLengthType(
             min_length=min_length, max_length=max_length, termination=termination, **kwargs)
@@ -48,23 +62,18 @@ class MinMaxLengthType(DiagCodedType):
                 DataType.A_UNICODE2STRING,
                 DataType.A_UTF8STRING,
             ], f"A min-max length type cannot have the base data type {self.base_data_type}.")
-        odxassert(self.termination in [
-            "ZERO",
-            "HEX-FF",
-            "END-OF-PDU",
-        ], f"A min-max length type cannot have the termination {self.termination}")
 
     def __termination_sequence(self) -> bytes:
         """Returns the termination byte sequence if it isn't defined."""
         # The termination sequence is actually not specified by ASAM
         # for A_BYTEFIELD but I assume it is only one byte.
         termination_sequence = b''
-        if self.termination == "ZERO":
+        if self.termination == Termination.ZERO:
             if self.base_data_type not in [DataType.A_UNICODE2STRING]:
                 termination_sequence = bytes([0x0])
             else:
                 termination_sequence = bytes([0x0, 0x0])
-        elif self.termination == "HEX-FF":
+        elif self.termination == Termination.HEX_FF:
             if self.base_data_type not in [DataType.A_UNICODE2STRING]:
                 termination_sequence = bytes([0xFF])
             else:
@@ -78,29 +87,52 @@ class MinMaxLengthType(DiagCodedType):
             odxraise("MinMaxLengthType is currently only implemented for strings and byte arrays",
                      EncodeError)
 
-        if self.max_length is not None:
-            data_length = min(len(internal_value), self.max_length)
+        raw_value = b''
+        if isinstance(internal_value, str):
+            str_encoding = get_string_encoding(self.base_data_type, self.base_type_encoding,
+                                               self.is_highlow_byte_order)
+
+            if str_encoding is None:
+                odxraise(f"Internal string value specified for object which is "
+                         f"'{self.base_data_type.value}' not a string")
+                raw_value = b''
+            else:
+                raw_value = internal_value.encode(str_encoding)
         else:
-            data_length = len(internal_value)
+            raw_value = bytes(internal_value)
+
+        data_length = len(raw_value)
+
+        if data_length < self.min_length:
+            odxraise(
+                f"Encoded value for MinMaxLengthType "
+                f"must be at least {self.min_length} bytes long. "
+                f"(Is: {data_length} bytes.)", EncodeError)
+            data_length = self.min_length
+        elif self.max_length is not None and data_length > self.max_length:
+            odxraise(
+                f"Encoded value for MinMaxLengthType "
+                f"must not be longer than {self.max_length} bytes. "
+                f"(Is: {data_length} bytes.)", EncodeError)
+            data_length = self.max_length
 
-        orig_cursor = encode_state.cursor_byte_position
         encode_state.emplace_atomic_value(
-            internal_value=internal_value,
+            internal_value=raw_value,
             used_mask=None,
             bit_length=8 * data_length,
-            base_data_type=self.base_data_type,
-            is_highlow_byte_order=self.is_highlow_byte_order,
+            base_data_type=DataType.A_BYTEFIELD,
+            base_type_encoding=None,
+            is_highlow_byte_order=True,
         )
-        value_len = encode_state.cursor_byte_position - orig_cursor
 
         # TODO: ensure that the termination delimiter is not
         # encountered within the encoded value.
 
         odxassert(
-            self.termination != "END-OF-PDU" or encode_state.is_end_of_pdu,
+            self.termination != Termination.END_OF_PDU or encode_state.is_end_of_pdu,
             "Encountered a MIN-MAX-LENGTH type with END-OF-PDU termination "
             "which is not located at the end of the PDU")
-        if encode_state.is_end_of_pdu or value_len == self.max_length:
+        if encode_state.is_end_of_pdu or data_length == self.max_length:
             # All termination types may be ended by the end of the PDU
             # or once reaching the maximum length. In this case, we
             # must not add the termination sequence
@@ -110,24 +142,11 @@ class MinMaxLengthType(DiagCodedType):
 
             # ensure that we don't try to encode an odd-length
             # value when using a two-byte terminator
-            odxassert(value_len % len(termination_sequence) == 0)
+            odxassert(data_length % len(termination_sequence) == 0)
 
-            value_len += len(termination_sequence)
+            data_length += len(termination_sequence)
             encode_state.emplace_bytes(termination_sequence)
 
-        if value_len < self.min_length:
-            odxraise(
-                f"Encoded value for MinMaxLengthType "
-                f"must be at least {self.min_length} bytes long. "
-                f"(Is: {value_len} bytes.)", EncodeError)
-            return
-        elif self.max_length is not None and value_len > self.max_length:
-            odxraise(
-                f"Encoded value for MinMaxLengthType "
-                f"must not be longer than {self.max_length} bytes. "
-                f"(Is: {value_len} bytes.)", EncodeError)
-            return
-
     def decode_from_pdu(self, decode_state: DecodeState) -> AtomicOdxType:
         odxassert(decode_state.cursor_bit_position == 0,
                   "No bit position can be specified for MIN-MAX-LENGTH-TYPE values.")
@@ -142,7 +161,7 @@ class MinMaxLengthType(DiagCodedType):
         if self.max_length is not None:
             max_terminator_pos = min(max_terminator_pos, orig_cursor_pos + self.max_length)
 
-        if self.termination != "END-OF-PDU":
+        if self.termination != Termination.END_OF_PDU:
             # The parameter either ends after the maximum length, at
             # the end of the PDU or if a termination sequence is
             # found.
@@ -180,6 +199,7 @@ class MinMaxLengthType(DiagCodedType):
             value = decode_state.extract_atomic_value(
                 bit_length=8 * byte_length,
                 base_data_type=self.base_data_type,
+                base_type_encoding=self.base_type_encoding,
                 is_highlow_byte_order=self.is_highlow_byte_order,
             )
 
@@ -198,6 +218,7 @@ class MinMaxLengthType(DiagCodedType):
             value = decode_state.extract_atomic_value(
                 bit_length=8 * byte_length,
                 base_data_type=self.base_data_type,
+                base_type_encoding=self.base_type_encoding,
                 is_highlow_byte_order=self.is_highlow_byte_order,
             )
 

odxtools/modification.py

@@ -3,18 +3,19 @@ from dataclasses import dataclass
 from typing import Any, Dict, List, Optional
 from xml.etree import ElementTree
 
+from .exceptions import odxrequire
 from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
 from .snrefcontext import SnRefContext
 
 
 @dataclass
 class Modification:
-    change: Optional[str]
+    change: str
     reason: Optional[str]
 
     @staticmethod
     def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "Modification":
-        change = et_element.findtext("CHANGE")
+        change = odxrequire(et_element.findtext("CHANGE"))
         reason = et_element.findtext("REASON")
 
         return Modification(change=change, reason=reason)

odxtools/odxcategory.py

@@ -8,7 +8,7 @@ from .companydata import CompanyData
 from .element import IdentifiableElement
 from .exceptions import odxrequire
 from .nameditemlist import NamedItemList
-from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
+from .odxlink import DocType, OdxDocFragment, OdxLinkDatabase, OdxLinkId
 from .snrefcontext import SnRefContext
 from .specialdatagroup import SpecialDataGroup
 from .utils import dataclass_fields_asdict
@@ -32,7 +32,7 @@ class OdxCategory(IdentifiableElement):
 
     @staticmethod
     def category_from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment], *,
-                         doc_type: str) -> "OdxCategory":
+                         doc_type: DocType) -> "OdxCategory":
 
         short_name = odxrequire(et_element.findtext("SHORT-NAME"))
         # create the current ODX "document fragment" (description of the

odxtools/odxlink.py

@@ -1,6 +1,7 @@
 # SPDX-License-Identifier: MIT
 import warnings
 from dataclasses import dataclass
+from enum import Enum
 from typing import Any, Dict, Iterable, List, Optional, Type, TypeVar, overload
 from xml.etree import ElementTree
 
@@ -8,10 +9,22 @@ from .exceptions import OdxWarning, odxassert, odxraise, odxrequire
 from .nameditemlist import OdxNamed, TNamed
 
 
+class DocType(Enum):
+    FLASH = "FLASH"
+    CONTAINER = "CONTAINER"
+    LAYER = "LAYER"
+    MULTIPLE_ECU_JOB_SPEC = "MULTIPLE-ECU-JOB-SPEC"
+    COMPARAM_SPEC = "COMPARAM-SPEC"
+    VEHICLE_INFO_SPEC = "VEHICLE-INFO-SPEC"
+    COMPARAM_SUBSET = "COMPARAM-SUBSET"
+    ECU_CONFIG = "ECU-CONFIG"
+    FUNCTION_DICTIONARY_SPEC = "FUNCTION-DICTIONARY-SPEC"
+
+
 @dataclass(frozen=True)
 class OdxDocFragment:
     doc_name: str
-    doc_type: str
+    doc_type: DocType
 
 
 @dataclass(frozen=True)
@@ -83,6 +96,10 @@ class OdxLinkRef:
     #: The document fragments to which the `ref_id` refers to (in reverse order)
     ref_docs: List[OdxDocFragment]
 
+    # TODO: this is difficult because OdxLinkRef is derived from and
+    # we do not want having to specify it mandatorily
+    #revision: Optional[str] = None
+
     @overload
     @staticmethod
     def from_et(et: None, source_doc_frags: List[OdxDocFragment]) -> None:
@@ -109,18 +126,25 @@ class OdxLinkRef:
             odxraise(f"Tag {et.tag} is not a ODXLINK reference")
             return None
 
-        doc_ref = et.attrib.get("DOCREF")
-        doc_type = et.attrib.get("DOCTYPE")
+        docref = et.attrib.get("DOCREF")
+        doctype_attr = et.attrib.get("DOCTYPE")
 
-        odxassert((doc_ref is not None and doc_type is not None) or
-                  (doc_ref is None and doc_type is None),
+        odxassert((docref is not None and doctype_attr is not None) or
+                  (docref is None and doctype_attr is None),
                   "DOCREF and DOCTYPE must both either be specified or omitted")
 
+        doctype = None
+        if doctype_attr is not None:
+            try:
+                doctype = DocType(doctype_attr)
+            except ValueError:
+                odxraise(f"Encountered unknown document type '{doctype_attr}'")
+
         # if the target document fragment is specified by the
         # reference, use it, else use the document fragment containing
         # the reference.
-        if doc_ref is not None:
-            doc_frags = [OdxDocFragment(doc_ref, odxrequire(doc_type))]
+        if docref is not None:
+            doc_frags = [OdxDocFragment(docref, odxrequire(doctype))]
         else:
             doc_frags = source_doc_frags
 

odxtools/odxtypes.py

@@ -157,7 +157,7 @@ def compare_odx_values(a: AtomicOdxType, b: AtomicOdxType) -> int:
 
 # format specifiers for the data type using the bitstruct module
 _BITSTRUCT_FORMAT_LETTER_MAP__ = {
-    "A_INT32": "s",
+    "A_INT32": "u",  # the sign must be handled separately
     "A_UINT32": "u",
     "A_FLOAT32": "f",
     "A_FLOAT64": "f",

odxtools/outputparam.py

@@ -3,6 +3,8 @@ from dataclasses import dataclass
 from typing import Any, Dict, List, Optional
 from xml.etree import ElementTree
 
+from deprecation import deprecated
+
 from .dopbase import DopBase
 from .element import IdentifiableElement
 from .exceptions import odxrequire
@@ -29,12 +31,15 @@ class OutputParam(IdentifiableElement):
         return {}
 
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
-        self._dop_base = odxlinks.resolve(self.dop_base_ref, DopBase)
+        self._dop = odxlinks.resolve(self.dop_base_ref, DopBase)
 
     def _resolve_snrefs(self, context: SnRefContext) -> None:
         pass
 
     @property
+    def dop(self) -> DopBase:
+        return self._dop
+
+    @deprecated(details="use .dop")  # type: ignore[misc]
     def dop_base(self) -> DopBase:
-        """The data object property describing this parameter."""
-        return self._dop_base
+        return self._dop

odxtools/parameters/matchingrequestparameter.py

@@ -79,4 +79,5 @@ class MatchingRequestParameter(Parameter):
         return decode_state.extract_atomic_value(
             bit_length=self.byte_length * 8,
             base_data_type=DataType.A_UINT32,
+            base_type_encoding=None,
             is_highlow_byte_order=False)

odxtools/parameters/physicalconstantparameter.py

@@ -54,6 +54,7 @@ class PhysicalConstantParameter(ParameterWithDOP):
         dop = odxrequire(self.dop)
         if not isinstance(dop, DataObjectProperty):
             odxraise("The type of PHYS-CONST parameters must be a simple DOP")
+            return
         base_data_type = dop.physical_type.base_data_type
         self._physical_constant_value = base_data_type.from_string(self.physical_constant_value_raw)
 

odxtools/parameters/reservedparameter.py

@@ -61,4 +61,5 @@ class ReservedParameter(Parameter):
         return decode_state.extract_atomic_value(
             bit_length=self.bit_length,
             base_data_type=DataType.A_UINT32,
+            base_type_encoding=None,
             is_highlow_byte_order=False)

odxtools/parameters/tableentryparameter.py

@@ -1,13 +1,14 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, List, Optional
+from enum import Enum
+from typing import TYPE_CHECKING, List, Optional, cast
 from xml.etree import ElementTree
 
 from typing_extensions import override
 
 from ..decodestate import DecodeState
 from ..encodestate import EncodeState
-from ..exceptions import odxrequire
+from ..exceptions import odxraise, odxrequire
 from ..odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkRef
 from ..odxtypes import ParameterValue
 from ..utils import dataclass_fields_asdict
@@ -17,9 +18,14 @@ if TYPE_CHECKING:
     from ..tablerow import TableRow
 
 
+class RowFragment(Enum):
+    KEY = "KEY"
+    STRUCT = "STRUCT"
+
+
 @dataclass
 class TableEntryParameter(Parameter):
-    target: str
+    target: RowFragment
     table_row_ref: OdxLinkRef
 
     @staticmethod
@@ -29,7 +35,12 @@ class TableEntryParameter(Parameter):
 
         kwargs = dataclass_fields_asdict(Parameter.from_et(et_element, doc_frags))
 
-        target = odxrequire(et_element.findtext("TARGET"))
+        target_str = odxrequire(et_element.findtext("TARGET"))
+        try:
+            target = RowFragment(target_str)
+        except ValueError:
+            odxraise(f"Encountered unknown target '{target_str}'")
+            target = cast(RowFragment, None)
         table_row_ref = odxrequire(OdxLinkRef.from_et(et_element.find("TABLE-ROW-REF"), doc_frags))
 
         return TableEntryParameter(target=target, table_row_ref=table_row_ref, **kwargs)

odxtools/parameters/tablekeyparameter.py

@@ -23,10 +23,16 @@ if TYPE_CHECKING:
 class TableKeyParameter(Parameter):
 
     odx_id: OdxLinkId
+
+    # the spec mandates that exactly one of the two attributes must
+    # be non-None
     table_ref: Optional[OdxLinkRef]
     table_snref: Optional[str]
-    table_row_snref: Optional[str]
+
+    # the spec mandates that exactly one of the two attributes must
+    # be non-None
     table_row_ref: Optional[OdxLinkRef]
+    table_row_snref: Optional[str]
 
     @staticmethod
     @override
@@ -58,9 +64,6 @@ class TableKeyParameter(Parameter):
     def __post_init__(self) -> None:
         self._table: Table
         self._table_row: Optional[TableRow] = None
-        if self.table_ref is None and self.table_snref is None and \
-           self.table_row_ref is None and self.table_row_snref is None:
-            odxraise("Either a table or a table row must be defined.")
 
     @property
     @override
@@ -86,17 +89,20 @@ class TableKeyParameter(Parameter):
             else:
                 self._table = odxlinks.resolve(self.table_ref)
 
-        if self.table_row_ref is not None:
+        elif self.table_row_ref is not None:
             if TYPE_CHECKING:
                 self._table_row = odxlinks.resolve(self.table_row_ref, TableRow)
             else:
                 self._table_row = odxlinks.resolve(self.table_row_ref)
 
-            if self.table_ref is None and self.table_snref is None:
-                if TYPE_CHECKING:
-                    self._table = odxlinks.resolve(self._table_row.table_ref, Table)
-                else:
-                    self._table = odxlinks.resolve(self._table_row.table_ref)
+            # be aware that we cannot simply use
+            # `self._table_row.table` here because the table object
+            # might not have resolved its references yet because the
+            # order of reference resolution is undefined
+            if TYPE_CHECKING:
+                self._table = odxlinks.resolve(self._table_row.table_ref, Table)
+            else:
+                self._table = odxlinks.resolve(self._table_row.table_ref)
 
     @override
     def _resolve_snrefs(self, context: SnRefContext) -> None:
@@ -108,16 +114,13 @@ class TableKeyParameter(Parameter):
                 self._table = resolve_snref(self.table_snref, tables, Table)
             else:
                 self._table = resolve_snref(self.table_snref, tables)
+
         if self.table_row_snref is not None:
-            # make sure that we know the table to which the table row
-            # SNREF is relative to.
-            table = odxrequire(
-                self._table, "If a table row is referenced via short name, a table must "
-                "be referenced as well")
             if TYPE_CHECKING:
-                self._table_row = resolve_snref(self.table_row_snref, table.table_rows, TableRow)
+                self._table_row = resolve_snref(self.table_row_snref, self._table.table_rows,
+                                                TableRow)
             else:
-                self._table_row = resolve_snref(self.table_row_snref, table.table_rows)
+                self._table_row = resolve_snref(self.table_row_snref, self._table.table_rows)
 
     @property
     def table(self) -> "Table":

odxtools/paramlengthinfotype.py

@@ -96,6 +96,7 @@ class ParamLengthInfoType(DiagCodedType):
             used_mask=None,
             bit_length=bit_length,
             base_data_type=self.base_data_type,
+            base_type_encoding=self.base_type_encoding,
             is_highlow_byte_order=self.is_highlow_byte_order,
         )
 
@@ -114,7 +115,8 @@ class ParamLengthInfoType(DiagCodedType):
 
         # Extract the internal value and return.
         return decode_state.extract_atomic_value(
-            bit_length,
-            self.base_data_type,
-            self.is_highlow_byte_order,
+            bit_length=bit_length,
+            base_data_type=self.base_data_type,
+            base_type_encoding=self.base_type_encoding,
+            is_highlow_byte_order=self.is_highlow_byte_order,
         )

odxtools/physicaltype.py

@@ -74,4 +74,5 @@ class PhysicalType:
         precision_str = et_element.findtext("PRECISION")
         precision = int(precision_str) if precision_str is not None else None
 
-        return PhysicalType(base_data_type, display_radix=display_radix, precision=precision)
+        return PhysicalType(
+            base_data_type=base_data_type, display_radix=display_radix, precision=precision)

odxtools/scaleconstr.py

@@ -25,8 +25,8 @@ class ScaleConstr:
 
     short_label: Optional[str]
     description: Optional[Description]
-    lower_limit: Optional[Limit]
-    upper_limit: Optional[Limit]
+    lower_limit: Limit
+    upper_limit: Limit
     validity: ValidType
     value_type: DataType
 
@@ -37,9 +37,9 @@ class ScaleConstr:
         description = Description.from_et(et_element.find("DESC"), doc_frags)
 
         lower_limit = Limit.limit_from_et(
-            et_element.find("LOWER-LIMIT"), doc_frags, value_type=value_type)
+            odxrequire(et_element.find("LOWER-LIMIT")), doc_frags, value_type=value_type)
         upper_limit = Limit.limit_from_et(
-            et_element.find("UPPER-LIMIT"), doc_frags, value_type=value_type)
+            odxrequire(et_element.find("UPPER-LIMIT")), doc_frags, value_type=value_type)
 
         validity_str = odxrequire(et_element.get("VALIDITY"))
         try: