switch creation of all parameters to the .from_et() pattern

Signed-off-by: Andreas Lauser <[email protected]>
Signed-off-by: Florian Jost <[email protected]>

odxtools/parameters/codedconstparameter.py

@@ -1,16 +1,19 @@
 # SPDX-License-Identifier: MIT
 import warnings
 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 override
 
+from ..createanydiagcodedtype import create_any_diag_coded_type_from_et
 from ..decodestate import DecodeState
 from ..diagcodedtype import DiagCodedType
 from ..encodestate import EncodeState
-from ..exceptions import DecodeError
-from ..odxlink import OdxLinkDatabase, OdxLinkId
+from ..exceptions import DecodeError, odxrequire
+from ..odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
 from ..odxtypes import AtomicOdxType, DataType
+from ..utils import dataclass_fields_asdict
 from .parameter import Parameter, ParameterType
 
 if TYPE_CHECKING:
@@ -23,23 +26,43 @@ class CodedConstParameter(Parameter):
     diag_coded_type: DiagCodedType
     coded_value: AtomicOdxType
 
+    @staticmethod
+    @override
+    def from_et(et_element: ElementTree.Element,
+                doc_frags: List[OdxDocFragment]) -> "CodedConstParameter":
+
+        kwargs = dataclass_fields_asdict(Parameter.from_et(et_element, doc_frags))
+
+        dct_elem = odxrequire(et_element.find("DIAG-CODED-TYPE"))
+        diag_coded_type = create_any_diag_coded_type_from_et(dct_elem, doc_frags)
+        coded_value = diag_coded_type.base_data_type.from_string(
+            odxrequire(et_element.findtext("CODED-VALUE")))
+
+        return CodedConstParameter(
+            diag_coded_type=diag_coded_type, coded_value=coded_value, **kwargs)
+
     @property
+    @override
     def parameter_type(self) -> ParameterType:
         return "CODED-CONST"
 
+    @override
     def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
         result = super()._build_odxlinks()
 
         result.update(self.diag_coded_type._build_odxlinks())
 
         return result
 
+    @override
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
         super()._resolve_odxlinks(odxlinks)
 
+    @override
     def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
         super()._resolve_snrefs(diag_layer)
 
+    @override
     def get_static_bit_length(self) -> Optional[int]:
         return self.diag_coded_type.get_static_bit_length()
 
@@ -48,13 +71,16 @@ def internal_data_type(self) -> DataType:
         return self.diag_coded_type.base_data_type
 
     @property
+    @override
     def is_required(self) -> bool:
         return False
 
     @property
+    @override
     def is_settable(self) -> bool:
         return False
 
+    @override
     def get_coded_value_as_bytes(self, encode_state: EncodeState) -> bytes:
         if (self.short_name in encode_state.parameter_values and
                 encode_state.parameter_values[self.short_name] != self.coded_value):

odxtools/parameters/createanyparameter.py

@@ -2,13 +2,9 @@
 from typing import List
 from xml.etree import ElementTree
 
-from ..createanydiagcodedtype import create_any_diag_coded_type_from_et
-from ..createsdgs import create_sdgs_from_et
-from ..element import NamedElement
-from ..exceptions import odxrequire
+from ..exceptions import odxraise
 from ..globals import xsi
-from ..odxlink import OdxDocFragment, OdxLinkId, OdxLinkRef
-from ..utils import dataclass_fields_asdict
+from ..odxlink import OdxDocFragment
 from .codedconstparameter import CodedConstParameter
 from .dynamicparameter import DynamicParameter
 from .lengthkeyparameter import LengthKeyParameter
@@ -27,205 +23,33 @@
 def create_any_parameter_from_et(et_element: ElementTree.Element,
                                  doc_frags: List[OdxDocFragment]) \
                                  -> Parameter:
-    kwargs = dataclass_fields_asdict(NamedElement.from_et(et_element, doc_frags))
-    semantic = et_element.get("SEMANTIC")
-    byte_position_str = et_element.findtext("BYTE-POSITION")
-    byte_position = int(byte_position_str) if byte_position_str is not None else None
-    bit_position_str = et_element.findtext("BIT-POSITION")
-    bit_position = None
-    if bit_position_str is not None:
-        bit_position = int(bit_position_str)
     parameter_type = et_element.get(f"{xsi}type")
 
-    sdgs = create_sdgs_from_et(et_element.find("SDGS"), doc_frags)
-
     # Which attributes are set depends on the type of the parameter.
-    dop_ref = None
-    dop_snref = None
-    if parameter_type in ["VALUE", "PHYS-CONST", "SYSTEM", "LENGTH-KEY"]:
-        dop_ref = OdxLinkRef.from_et(et_element.find("DOP-REF"), doc_frags)
-        dop_snref = None
-        if (dop_snref_elem := et_element.find("DOP-SNREF")) is not None:
-            dop_snref = odxrequire(dop_snref_elem.get("SHORT-NAME"))
-
-        if dop_ref is None and dop_snref is None:
-            raise ValueError(
-                f"A parameter of type {parameter_type} must reference a DOP! {dop_ref}, {dop_snref}"
-            )
-
     if parameter_type == "VALUE":
-        physical_default_value_raw = (
-            et_element.findtext("PHYSICAL-DEFAULT-VALUE")
-            if et_element.find("PHYSICAL-DEFAULT-VALUE") is not None else None)
-
-        return ValueParameter(
-            semantic=semantic,
-            byte_position=byte_position,
-            bit_position=bit_position,
-            dop_ref=dop_ref,
-            dop_snref=dop_snref,
-            physical_default_value_raw=physical_default_value_raw,
-            sdgs=sdgs,
-            **kwargs)
-
-    elif parameter_type == "PHYS-CONST":
-        physical_constant_value = odxrequire(et_element.findtext("PHYS-CONSTANT-VALUE"))
-
-        return PhysicalConstantParameter(
-            semantic=semantic,
-            byte_position=byte_position,
-            bit_position=bit_position,
-            dop_ref=dop_ref,
-            dop_snref=dop_snref,
-            physical_constant_value_raw=physical_constant_value,
-            sdgs=sdgs,
-            **kwargs)
-
+        return ValueParameter.from_et(et_element, doc_frags)
     elif parameter_type == "CODED-CONST":
-        dct_elem = odxrequire(et_element.find("DIAG-CODED-TYPE"))
-        diag_coded_type = create_any_diag_coded_type_from_et(dct_elem, doc_frags)
-        coded_value = diag_coded_type.base_data_type.from_string(
-            odxrequire(et_element.findtext("CODED-VALUE")))
-
-        return CodedConstParameter(
-            semantic=semantic,
-            diag_coded_type=diag_coded_type,
-            coded_value=coded_value,
-            byte_position=byte_position,
-            bit_position=bit_position,
-            sdgs=sdgs,
-            **kwargs)
-
+        return CodedConstParameter.from_et(et_element, doc_frags)
+    elif parameter_type == "PHYS-CONST":
+        return PhysicalConstantParameter.from_et(et_element, doc_frags)
+    elif parameter_type == "SYSTEM":
+        return SystemParameter.from_et(et_element, doc_frags)
+    elif parameter_type == "LENGTH-KEY":
+        return LengthKeyParameter.from_et(et_element, doc_frags)
     elif parameter_type == "NRC-CONST":
-        diag_coded_type = create_any_diag_coded_type_from_et(
-            odxrequire(et_element.find("DIAG-CODED-TYPE")), doc_frags)
-        coded_values = [
-            diag_coded_type.base_data_type.from_string(odxrequire(val.text))
-            for val in et_element.iterfind("CODED-VALUES/CODED-VALUE")
-        ]
-
-        return NrcConstParameter(
-            semantic=semantic,
-            diag_coded_type=diag_coded_type,
-            coded_values=coded_values,
-            byte_position=byte_position,
-            bit_position=bit_position,
-            sdgs=sdgs,
-            **kwargs)
-
+        return NrcConstParameter.from_et(et_element, doc_frags)
     elif parameter_type == "RESERVED":
-        bit_length = int(odxrequire(et_element.findtext("BIT-LENGTH")))
-
-        return ReservedParameter(
-            bit_length=bit_length,
-            semantic=semantic,
-            byte_position=byte_position,
-            bit_position=bit_position,
-            sdgs=sdgs,
-            **kwargs)
-
+        return ReservedParameter.from_et(et_element, doc_frags)
     elif parameter_type == "MATCHING-REQUEST-PARAM":
-        byte_length = int(odxrequire(et_element.findtext("BYTE-LENGTH")))
-        request_byte_pos = int(odxrequire(et_element.findtext("REQUEST-BYTE-POS")))
-
-        return MatchingRequestParameter(
-            semantic=semantic,
-            byte_position=byte_position,
-            bit_position=bit_position,
-            request_byte_position=request_byte_pos,
-            byte_length=byte_length,
-            sdgs=sdgs,
-            **kwargs)
-
-    elif parameter_type == "SYSTEM":
-        sysparam = odxrequire(et_element.get("SYSPARAM"))
-
-        return SystemParameter(
-            sysparam=sysparam,
-            semantic=semantic,
-            byte_position=byte_position,
-            bit_position=bit_position,
-            dop_ref=dop_ref,
-            dop_snref=dop_snref,
-            sdgs=sdgs,
-            **kwargs)
-
-    elif parameter_type == "LENGTH-KEY":
-        odx_id = odxrequire(OdxLinkId.from_et(et_element, doc_frags))
-
-        return LengthKeyParameter(
-            odx_id=odx_id,
-            semantic=semantic,
-            byte_position=byte_position,
-            bit_position=bit_position,
-            dop_ref=dop_ref,
-            dop_snref=dop_snref,
-            sdgs=sdgs,
-            **kwargs)
-
+        return MatchingRequestParameter.from_et(et_element, doc_frags)
     elif parameter_type == "DYNAMIC":
-
-        return DynamicParameter(
-            semantic=semantic,
-            byte_position=byte_position,
-            bit_position=bit_position,
-            sdgs=sdgs,
-            **kwargs)
-
+        return DynamicParameter.from_et(et_element, doc_frags)
     elif parameter_type == "TABLE-STRUCT":
-        key_ref = OdxLinkRef.from_et(et_element.find("TABLE-KEY-REF"), doc_frags)
-        if (key_snref_elem := et_element.find("TABLE-KEY-SNREF")) is not None:
-            key_snref = odxrequire(key_snref_elem.get("SHORT-NAME"))
-        else:
-            key_snref = None
-
-        return TableStructParameter(
-            table_key_ref=key_ref,
-            table_key_snref=key_snref,
-            semantic=semantic,
-            byte_position=byte_position,
-            bit_position=bit_position,
-            sdgs=sdgs,
-            **kwargs)
-
+        return TableStructParameter.from_et(et_element, doc_frags)
     elif parameter_type == "TABLE-KEY":
-
-        parameter_id = odxrequire(OdxLinkId.from_et(et_element, doc_frags))
-        table_ref = OdxLinkRef.from_et(et_element.find("TABLE-REF"), doc_frags)
-        if (table_snref_elem := et_element.find("TABLE-SNREF")) is not None:
-            table_snref = odxrequire(table_snref_elem.get("SHORT-NAME"))
-        else:
-            table_snref = None
-
-        table_row_ref = OdxLinkRef.from_et(et_element.find("TABLE-ROW-REF"), doc_frags)
-        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"))
-        else:
-            table_row_snref = None
-
-        return TableKeyParameter(
-            table_ref=table_ref,
-            table_snref=table_snref,
-            table_row_snref=table_row_snref,
-            table_row_ref=table_row_ref,
-            odx_id=parameter_id,
-            byte_position=byte_position,
-            bit_position=bit_position,
-            semantic=semantic,
-            sdgs=sdgs,
-            **kwargs)
-
+        return TableKeyParameter.from_et(et_element, doc_frags)
     elif parameter_type == "TABLE-ENTRY":
-        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,
-            byte_position=byte_position,
-            bit_position=bit_position,
-            semantic=semantic,
-            sdgs=sdgs,
-            **kwargs)
+        return TableEntryParameter.from_et(et_element, doc_frags)
 
-    raise NotImplementedError(f"I don't know about parameters of type {parameter_type}")
+    odxraise(f"I don't know about parameters of type {parameter_type}", NotImplementedError)
+    return Parameter.from_et(et_element, doc_frags)

odxtools/parameters/dynamicparameter.py

@@ -1,32 +1,50 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
+from typing import List
+from xml.etree import ElementTree
 
 from typing_extensions import override
 
 from ..decodestate import DecodeState
 from ..encodestate import EncodeState
+from ..odxlink import OdxDocFragment
 from ..odxtypes import ParameterValue
+from ..utils import dataclass_fields_asdict
 from .parameter import Parameter, ParameterType
 
 
 @dataclass
 class DynamicParameter(Parameter):
 
+    @staticmethod
+    @override
+    def from_et(et_element: ElementTree.Element,
+                doc_frags: List[OdxDocFragment]) -> "DynamicParameter":
+
+        kwargs = dataclass_fields_asdict(Parameter.from_et(et_element, doc_frags))
+
+        return DynamicParameter(**kwargs)
+
     @property
+    @override
     def parameter_type(self) -> ParameterType:
         return "DYNAMIC"
 
     @property
+    @override
     def is_required(self) -> bool:
         raise NotImplementedError(".is_required for a DynamicParameter")
 
     @property
+    @override
     def is_settable(self) -> bool:
         raise NotImplementedError(".is_settable for a DynamicParameter")
 
+    @override
     def get_coded_value_as_bytes(self, encode_state: EncodeState) -> bytes:
         raise NotImplementedError("Encoding a DynamicParameter is not implemented yet.")
 
+    @override
     @override
     def _decode_positioned_from_pdu(self, decode_state: DecodeState) -> ParameterValue:
         raise NotImplementedError("Decoding a DynamicParameter is not implemented yet.")