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

odxtools/parameters/reservedparameter.py

@@ -1,10 +1,16 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import Optional, cast
+from typing import List, Optional
+from xml.etree import ElementTree
+
+from typing_extensions import override
 
 from ..decodestate import DecodeState
 from ..encodestate import EncodeState
-from ..odxtypes import ParameterValue
+from ..exceptions import odxrequire
+from ..odxlink import OdxDocFragment
+from ..odxtypes import DataType, ParameterValue
+from ..utils import dataclass_fields_asdict
 from .parameter import Parameter, ParameterType
 
 
@@ -12,35 +18,47 @@ from .parameter import Parameter, ParameterType
 class ReservedParameter(Parameter):
     bit_length: int
 
+    @staticmethod
+    @override
+    def from_et(et_element: ElementTree.Element,
+                doc_frags: List[OdxDocFragment]) -> "ReservedParameter":
+
+        kwargs = dataclass_fields_asdict(Parameter.from_et(et_element, doc_frags))
+
+        bit_length = int(odxrequire(et_element.findtext("BIT-LENGTH")))
+
+        return ReservedParameter(bit_length=bit_length, **kwargs)
+
     @property
+    @override
     def parameter_type(self) -> ParameterType:
         return "RESERVED"
 
     @property
+    @override
     def is_required(self) -> bool:
         return False
 
     @property
+    @override
     def is_settable(self) -> bool:
         return False
 
+    @override
     def get_static_bit_length(self) -> Optional[int]:
         return self.bit_length
 
-    def get_coded_value_as_bytes(self, encode_state: EncodeState) -> bytes:
-        bit_position_int = self.bit_position if self.bit_position is not None else 0
-        return (0).to_bytes((self.bit_length + bit_position_int + 7) // 8, "big")
-
-    def decode_from_pdu(self, decode_state: DecodeState) -> ParameterValue:
-        # move the cursor
-        orig_cursor = decode_state.cursor_byte_position
-        if self.byte_position is not None:
-            decode_state.cursor_byte_position = decode_state.origin_byte_position + self.byte_position
-
-        decode_state.cursor_byte_position += ((self.bit_position or 0) + self.bit_length + 7) // 8
-
-        decode_state.cursor_byte_position = max(orig_cursor, decode_state.cursor_byte_position)
-        decode_state.cursor_bit_position = 0
+    @override
+    def _encode_positioned_into_pdu(self, physical_value: Optional[ParameterValue],
+                                    encode_state: EncodeState) -> None:
+        encode_state.cursor_byte_position += (encode_state.cursor_bit_position + self.bit_length +
+                                              7) // 8
+        encode_state.cursor_bit_position = 0
+        encode_state.emplace_bytes(b'', self.short_name)
 
-        # ignore the value of the parameter data
-        return cast(int, None)
+    @override
+    def _decode_positioned_from_pdu(self, decode_state: DecodeState) -> ParameterValue:
+        return decode_state.extract_atomic_value(
+            bit_length=self.bit_length,
+            base_data_type=DataType.A_UINT32,
+            is_highlow_byte_order=False)

odxtools/parameters/systemparameter.py

@@ -1,31 +1,98 @@
 # SPDX-License-Identifier: MIT
+import getpass
 from dataclasses import dataclass
+from datetime import datetime
+from typing import List, Optional
+from xml.etree import ElementTree
+
+from typing_extensions import override
 
-from ..decodestate import DecodeState
 from ..encodestate import EncodeState
+from ..exceptions import odxraise, odxrequire
+from ..odxlink import OdxDocFragment
 from ..odxtypes import ParameterValue
+from ..utils import dataclass_fields_asdict
 from .parameter import ParameterType
 from .parameterwithdop import ParameterWithDOP
 
+# The SYSTEM parameter types mandated by the ODX 2.2 standard. Users
+# are free to specify additional types, but these must be handled
+# (cf. table 5 in section 7.3.5.4 of the ASAM ODX 2.2 specification
+# document.)
+PREDEFINED_SYSPARAM_VALUES = [
+    "TIMESTAMP", "SECOND", "MINUTE", "HOUR", "TIMEZONE", "DAY", "WEEK", "MONTH", "YEAR", "CENTURY",
+    "TESTERID", "USERID"
+]
+
 
 @dataclass
 class SystemParameter(ParameterWithDOP):
     sysparam: str
 
+    @staticmethod
+    @override
+    def from_et(et_element: ElementTree.Element,
+                doc_frags: List[OdxDocFragment]) -> "SystemParameter":
+
+        kwargs = dataclass_fields_asdict(ParameterWithDOP.from_et(et_element, doc_frags))
+
+        sysparam = odxrequire(et_element.get("SYSPARAM"))
+
+        return SystemParameter(sysparam=sysparam, **kwargs)
+
     @property
+    @override
     def parameter_type(self) -> ParameterType:
         return "SYSTEM"
 
     @property
+    @override
     def is_required(self) -> bool:
-        raise NotImplementedError("SystemParameter.is_required is not implemented yet.")
+        # if a SYSTEM parameter is not specified explicitly, its value
+        # can be determined from the operating system if it is type is
+        # predefined
+        return self.sysparam not in PREDEFINED_SYSPARAM_VALUES
 
     @property
+    @override
     def is_settable(self) -> bool:
-        raise NotImplementedError("SystemParameter.is_settable is not implemented yet.")
+        return True
 
-    def get_coded_value_as_bytes(self, encode_state: EncodeState) -> bytes:
-        raise NotImplementedError("Encoding a SystemParameter is not implemented yet.")
+    @override
+    def _encode_positioned_into_pdu(self, physical_value: Optional[ParameterValue],
+                                    encode_state: EncodeState) -> None:
+        if physical_value is None:
+            # determine the value to be encoded automatically
+            now = datetime.now()
+            if self.sysparam == "TIMESTAMP":
+                physical_value = round(now.timestamp() * 1000).to_bytes(8, "big")
+            elif self.sysparam == "SECOND":
+                physical_value = now.second
+            elif self.sysparam == "MINUTE":
+                physical_value = now.minute
+            elif self.sysparam == "HOUR":
+                physical_value = now.hour
+            elif self.sysparam == "TIMEZONE":
+                if (utc_offset := now.astimezone().utcoffset()) is not None:
+                    physical_value = utc_offset.seconds // 60
+                else:
+                    physical_value = 0
+            elif self.sysparam == "DAY":
+                physical_value = now.day
+            elif self.sysparam == "WEEK":
+                physical_value = now.isocalendar()[1]
+            elif self.sysparam == "MONTH":
+                physical_value = now.month
+            elif self.sysparam == "YEAR":
+                physical_value = now.year
+            elif self.sysparam == "CENTURY":
+                physical_value = now.year // 100
+            elif self.sysparam == "TESTERID":
+                physical_value = "odxtools".encode("latin1")
+            elif self.sysparam == "USERID":
+                physical_value = getpass.getuser().encode("latin1")
+            else:
+                odxraise(f"Unknown system parameter type '{self.sysparam}'")
+                physical_value = 0
 
-    def decode_from_pdu(self, decode_state: DecodeState) -> ParameterValue:
-        raise NotImplementedError("Decoding a SystemParameter is not implemented yet.")
+        self.dop.encode_into_pdu(physical_value, encode_state=encode_state)

odxtools/parameters/tableentryparameter.py

@@ -1,32 +1,72 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
+from typing import TYPE_CHECKING, List, Optional
+from xml.etree import ElementTree
+
+from typing_extensions import override
 
 from ..decodestate import DecodeState
 from ..encodestate import EncodeState
-from ..odxlink import OdxLinkRef
+from ..exceptions import odxrequire
+from ..odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkRef
 from ..odxtypes import ParameterValue
+from ..utils import dataclass_fields_asdict
 from .parameter import Parameter, ParameterType
 
+if TYPE_CHECKING:
+    from ..tablerow import TableRow
+
 
 @dataclass
 class TableEntryParameter(Parameter):
     target: str
     table_row_ref: OdxLinkRef
 
+    @staticmethod
+    @override
+    def from_et(et_element: ElementTree.Element,
+                doc_frags: List[OdxDocFragment]) -> "TableEntryParameter":
+
+        kwargs = dataclass_fields_asdict(Parameter.from_et(et_element, doc_frags))
+
+        target = odxrequire(et_element.findtext("TARGET"))
+        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)
+
+    @override
+    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
+        super()._resolve_odxlinks(odxlinks)
+
+        if TYPE_CHECKING:
+            self._table_row = odxlinks.resolve(self.table_row_ref, TableRow)
+        else:
+            self._table_row = odxlinks.resolve(self.table_row_ref)
+
     @property
+    @override
     def parameter_type(self) -> ParameterType:
         return "TABLE-ENTRY"
 
     @property
+    @override
     def is_required(self) -> bool:
-        raise NotImplementedError("TableKeyParameter.is_required is not implemented yet.")
+        raise NotImplementedError("TableEntryParameter.is_required is not implemented yet.")
 
     @property
+    @override
     def is_settable(self) -> bool:
-        raise NotImplementedError("TableKeyParameter.is_settable is not implemented yet.")
+        raise NotImplementedError("TableEntryParameter.is_settable is not implemented yet.")
 
-    def get_coded_value_as_bytes(self, encode_state: EncodeState) -> bytes:
-        raise NotImplementedError("Encoding a TableKeyParameter is not implemented yet.")
+    @override
+    def _encode_positioned_into_pdu(self, physical_value: Optional[ParameterValue],
+                                    encode_state: EncodeState) -> None:
+        raise NotImplementedError("Encoding a TableEntryParameter is not implemented yet.")
+
+    @property
+    def table_row(self) -> "TableRow":
+        return self._table_row
 
-    def decode_from_pdu(self, decode_state: DecodeState) -> ParameterValue:
-        raise NotImplementedError("Decoding a TableKeyParameter is not implemented yet.")
+    @override
+    def _decode_positioned_from_pdu(self, decode_state: DecodeState) -> ParameterValue:
+        raise NotImplementedError("Decoding a TableEntryParameter is not implemented yet.")

odxtools/parameters/tablekeyparameter.py

@@ -1,16 +1,20 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Dict, Optional
+from typing import TYPE_CHECKING, Any, Dict, List, Optional
+from xml.etree import ElementTree
+
+from typing_extensions import final, override
 
 from ..decodestate import DecodeState
 from ..encodestate import EncodeState
 from ..exceptions import DecodeError, EncodeError, odxraise, odxrequire
-from ..odxlink import OdxLinkDatabase, OdxLinkId, OdxLinkRef
+from ..odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef, resolve_snref
 from ..odxtypes import ParameterValue
+from ..snrefcontext import SnRefContext
+from ..utils import dataclass_fields_asdict
 from .parameter import Parameter, ParameterType
 
 if TYPE_CHECKING:
-    from ..diaglayer import DiagLayer
     from ..table import Table
     from ..tablerow import TableRow
 
@@ -24,17 +28,46 @@ class TableKeyParameter(Parameter):
     table_row_snref: Optional[str]
     table_row_ref: Optional[OdxLinkRef]
 
+    @staticmethod
+    @override
+    def from_et(et_element: ElementTree.Element,
+                doc_frags: List[OdxDocFragment]) -> "TableKeyParameter":
+
+        kwargs = dataclass_fields_asdict(Parameter.from_et(et_element, doc_frags))
+
+        odx_id = odxrequire(OdxLinkId.from_et(et_element, doc_frags))
+
+        table_ref = OdxLinkRef.from_et(et_element.find("TABLE-REF"), doc_frags)
+        table_snref = None
+        if (table_snref_elem := et_element.find("TABLE-SNREF")) is not None:
+            table_snref = odxrequire(table_snref_elem.get("SHORT-NAME"))
+
+        table_row_ref = OdxLinkRef.from_et(et_element.find("TABLE-ROW-REF"), doc_frags)
+        table_row_snref = None
+        if (table_row_snref_elem := et_element.find("TABLE-ROW-SNREF")) is not None:
+            table_row_snref = odxrequire(table_row_snref_elem.get("SHORT-NAME"))
+
+        return TableKeyParameter(
+            odx_id=odx_id,
+            table_ref=table_ref,
+            table_snref=table_snref,
+            table_row_ref=table_row_ref,
+            table_row_snref=table_row_snref,
+            **kwargs)
+
     def __post_init__(self) -> None:
-        self._table: "Table"
-        self._table_row: Optional["TableRow"] = 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
     def parameter_type(self) -> ParameterType:
         return "TABLE-KEY"
 
+    @override
     def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
         result = super()._build_odxlinks()
 
@@ -42,104 +75,161 @@ class TableKeyParameter(Parameter):
 
         return result
 
+    @override
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
         super()._resolve_odxlinks(odxlinks)
 
         # Either table_ref or table_row_ref will be defined
-        if self.table_ref:
+        if self.table_ref is not None:
             if TYPE_CHECKING:
                 self._table = odxlinks.resolve(self.table_ref, Table)
             else:
                 self._table = odxlinks.resolve(self.table_ref)
 
-        if self.table_row_ref:
+        if 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)
-            self._table = self._table_row.table
 
-    def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
-        super()._resolve_snrefs(diag_layer)
+            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)
+
+    @override
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
+        super()._resolve_snrefs(context)
 
         if self.table_snref is not None:
-            ddd_spec = diag_layer.diag_data_dictionary_spec
-            self._table = ddd_spec.tables[self.table_snref]
+            tables = odxrequire(context.diag_layer).diag_data_dictionary_spec.tables
+            if TYPE_CHECKING:
+                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 short name reference is defined, a "
-                "table must also be specified.")
-            self._table_row = table.table_rows[self.table_row_snref]
+                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)
+            else:
+                self._table_row = resolve_snref(self.table_row_snref, table.table_rows)
 
     @property
     def table(self) -> "Table":
-        if self._table is not None:
-            return self._table
-        if self._table_row is not None:
-            return self._table_row.table
-        odxraise(f'Could not resolve the table of {self.short_name}')
+        return self._table
 
     @property
     def table_row(self) -> Optional["TableRow"]:
         return self._table_row
 
     @property
+    @override
     def is_required(self) -> bool:
         # TABLE-KEY parameters can be implicitly determined from the
         # corresponding TABLE-STRUCT
         return False
 
     @property
+    @override
     def is_settable(self) -> bool:
         return True
 
-    def get_coded_value_as_bytes(self, encode_state: EncodeState) -> bytes:
-        tr_short_name = encode_state.parameter_values.get(self.short_name)
+    @override
+    @final
+    def _encode_positioned_into_pdu(self, physical_value: Optional[ParameterValue],
+                                    encode_state: EncodeState) -> None:
+        # if you get this exception, you ought to use
+        # `.encode_placeholder_into_pdu()` followed by (after the
+        # value of the table key has been determined)
+        # `.encode_value_into_pdu()`.
+        raise RuntimeError("_encode_positioned_into_pdu() cannot be called for table keys.")
 
-        if tr_short_name is None:
-            # the table key has not been defined explicitly yet, but
-            # it is most likely implicitly defined by the associated
-            # TABLE-STRUCT parameters. Use all-zeros as a standin for
-            # the real data...
+    def encode_placeholder_into_pdu(self, physical_value: Optional[ParameterValue],
+                                    encode_state: EncodeState) -> None:
+
+        if physical_value is not None:
             key_dop = self.table.key_dop
             if key_dop is None:
-                raise EncodeError(f"Table '{self.table.short_name}' does not define "
-                                  f"a KEY-DOP, but is used in TABLE-KEY parameter "
-                                  f"'{self.short_name}'")
+                odxraise(
+                    f"Table '{self.table.short_name}' does not define "
+                    f"a KEY-DOP, but is used by TABLE-KEY parameter "
+                    f"'{self.short_name}'", EncodeError)
+                return
+
+            if not isinstance(physical_value, str):
+                odxraise(f"Invalid type for for table key '{self.short_name}' specified. "
+                         f"(expect name of table row.)")
+
+            tkv = encode_state.table_keys.get(self.short_name)
+            if tkv is not None and tkv != physical_value:
+                odxraise(f"Got conflicting values for table key {self.short_name}: "
+                         f"{tkv} and {physical_value!r}")
+
+            encode_state.table_keys[self.short_name] = physical_value
 
-            byte_len = (odxrequire(key_dop.get_static_bit_length()) + 7) // 8
-            if self.bit_position is not None and self.bit_position > 0:
-                byte_len += 1
+        pos = encode_state.cursor_byte_position
+        if self.byte_position is not None:
+            pos = encode_state.origin_byte_position + self.byte_position
+        encode_state.key_pos[self.short_name] = pos
+        encode_state.cursor_byte_position = pos
+        encode_state.cursor_bit_position = self.bit_position or 0
+
+        key_dop = self.table.key_dop
+        if key_dop is None:
+            odxraise(f"No KEY-DOP specified for table {self.table.short_name}")
+            return
+
+        sz = key_dop.get_static_bit_length()
+        if sz is None:
+            odxraise("The DOP of table key {self.short_name} must exhibit a fixed size.",
+                     EncodeError)
+            return
+
+        # emplace a value of zero into the encode state, but pretend the bits not to be used
+        n = sz + encode_state.cursor_bit_position
+        tmp_val = b'\x00' * ((n + 7) // 8)
+        encode_state.emplace_bytes(tmp_val, obj_used_mask=tmp_val)
+
+        encode_state.cursor_bit_position = 0
+
+    def encode_value_into_pdu(self, encode_state: EncodeState) -> None:
 
-            return bytes([0] * byte_len)
+        key_dop = self.table.key_dop
+        if key_dop is None:
+            odxraise(
+                f"Table '{self.table.short_name}' does not define "
+                f"a KEY-DOP, but is used by TABLE-KEY parameter "
+                f"'{self.short_name}'", EncodeError)
+            return
+
+        if self.short_name not in encode_state.table_keys:
+            odxraise(f"Table key {self.short_name} has not been defined before "
+                     f"it is required.", EncodeError)
+            return
+        else:
+            tr_short_name = encode_state.table_keys[self.short_name]
 
-        # the table key is known. We need to encode the associated DOP
-        # into the PDU.
+        # We need to encode the table key using the associated DOP into the PDU.
         tr_candidates = [x for x in self.table.table_rows if x.short_name == tr_short_name]
         if len(tr_candidates) == 0:
-            raise EncodeError(f"No table row with short name '{tr_short_name}' found")
+            odxraise(f"No table row with short name '{tr_short_name}' found", EncodeError)
+            return
         elif len(tr_candidates) > 1:
-            raise EncodeError(f"Multiple rows exhibiting short name '{tr_short_name}'")
+            odxraise(f"Multiple rows exhibiting short name '{tr_short_name}'", EncodeError)
         tr = tr_candidates[0]
 
-        key_dop = self.table.key_dop
-        if key_dop is None:
-            raise EncodeError(f"Table '{self.table.short_name}' does not define "
-                              f"a KEY-DOP, but is used in TABLE-KEY parameter "
-                              f"'{self.short_name}'")
-        bit_position = 0 if self.bit_position is None else self.bit_position
-        return key_dop.convert_physical_to_bytes(tr.key, encode_state, bit_position=bit_position)
-
-    def encode_into_pdu(self, encode_state: EncodeState) -> bytes:
-        return super().encode_into_pdu(encode_state)
+        encode_state.cursor_byte_position = encode_state.key_pos[self.short_name]
+        encode_state.cursor_bit_position = self.bit_position or 0
 
-    def decode_from_pdu(self, decode_state: DecodeState) -> ParameterValue:
-        orig_cursor = decode_state.cursor_byte_position
-        if self.byte_position is not None:
-            decode_state.cursor_byte_position = decode_state.origin_byte_position + self.byte_position
+        key_dop.encode_into_pdu(encode_state=encode_state, physical_value=odxrequire(tr.key))
 
+    @override
+    def _decode_positioned_from_pdu(self, decode_state: DecodeState) -> ParameterValue:
         if self.table_row is not None:
             # the table row to be used is statically specified -> no
             # need to decode anything!
@@ -147,7 +237,6 @@ class TableKeyParameter(Parameter):
         else:
             # Use DOP to decode
             key_dop = odxrequire(self.table.key_dop)
-            decode_state.cursor_bit_position = self.bit_position or 0
             key_dop_val = key_dop.decode_from_pdu(decode_state)
 
             table_row_candidates = [x for x in self.table.table_rows if x.key == key_dop_val]
@@ -162,6 +251,4 @@ class TableKeyParameter(Parameter):
             # update the decode_state's table key
             decode_state.table_keys[self.short_name] = table_row
 
-        decode_state.cursor_byte_position = max(decode_state.cursor_byte_position, orig_cursor)
-
         return phys_val