odxtools 9.4.1__py3-none-any.whl → 9.6.0__py3-none-any.whl

odxtools/parameters/nrcconstparameter.py

@@ -34,8 +34,31 @@ class NrcConstParameter(Parameter):
 
     """
 
+    coded_values_raw: List[str]
     diag_coded_type: DiagCodedType
-    coded_values: List[AtomicOdxType]
+
+    @property
+    @override
+    def parameter_type(self) -> ParameterType:
+        return "NRC-CONST"
+
+    @property
+    @override
+    def is_required(self) -> bool:
+        return False
+
+    @property
+    @override
+    def is_settable(self) -> bool:
+        return False
+
+    @property
+    def internal_data_type(self) -> DataType:
+        return self.diag_coded_type.base_data_type
+
+    @property
+    def coded_values(self) -> List[AtomicOdxType]:
+        return self._coded_values
 
     @staticmethod
     @override
@@ -44,20 +67,19 @@ class NrcConstParameter(Parameter):
 
         kwargs = dataclass_fields_asdict(Parameter.from_et(et_element, doc_frags))
 
+        coded_values_raw = [
+            odxrequire(x.text) for x in et_element.iterfind("CODED-VALUES/CODED-VALUE")
+        ]
         dct_elem = odxrequire(et_element.find("DIAG-CODED-TYPE"))
         diag_coded_type = create_any_diag_coded_type_from_et(dct_elem, 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(
-            diag_coded_type=diag_coded_type, coded_values=coded_values, **kwargs)
+            coded_values_raw=coded_values_raw, diag_coded_type=diag_coded_type, **kwargs)
 
-    @property
-    @override
-    def parameter_type(self) -> ParameterType:
-        return "NRC-CONST"
+    def __post_init__(self) -> None:
+        self._coded_values = [
+            self.diag_coded_type.base_data_type.from_string(val) for val in self.coded_values_raw
+        ]
 
     @override
     def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
@@ -71,20 +93,6 @@ class NrcConstParameter(Parameter):
     def get_static_bit_length(self) -> Optional[int]:
         return self.diag_coded_type.get_static_bit_length()
 
-    @property
-    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 _encode_positioned_into_pdu(self, physical_value: Optional[ParameterValue],
                                     encode_state: EncodeState) -> None:

odxtools/parameters/parameter.py

@@ -42,11 +42,39 @@ class Parameter(NamedElement):
     non-positionable parameter types.
 
     """
+    sdgs: List[SpecialDataGroup]
+    semantic: Optional[str]
     oid: Optional[str]
     byte_position: Optional[int]
     bit_position: Optional[int]
-    semantic: Optional[str]
-    sdgs: List[SpecialDataGroup]
+
+    @property
+    def parameter_type(self) -> ParameterType:
+        raise NotImplementedError(
+            ".parameter_type is not implemented by the concrete parameter class")
+
+    @property
+    def is_required(self) -> bool:
+        """True if the parameter must be explicitly specified when
+        encoding a message.
+
+        Required parameters are always settable, and parameters which
+        have a default value are settable but not required to be
+        specified.
+
+        """
+        raise NotImplementedError(".is_required is not implemented by the concrete parameter class")
+
+    @property
+    def is_settable(self) -> bool:
+        """True if the parameter can be specified when encoding a
+        message.
+
+        Required parameters are always settable, and parameters which
+        have a default value are settable but not required to be
+        specified.
+        """
+        raise NotImplementedError(".is_settable is not implemented by the concrete parameter class")
 
     @staticmethod
     @override
@@ -54,24 +82,22 @@ class Parameter(NamedElement):
 
         kwargs = dataclass_fields_asdict(NamedElement.from_et(et_element, doc_frags))
 
-        oid = et_element.get("OID")
-        semantic = et_element.get("SEMANTIC")
         sdgs = [
             SpecialDataGroup.from_et(sdge, doc_frags) for sdge in et_element.iterfind("SDGS/SDG")
         ]
-
+        semantic = et_element.attrib.get("SEMANTIC")
+        oid = et_element.attrib.get("OID")
         byte_position_str = et_element.findtext("BYTE-POSITION")
-        bit_position_str = et_element.findtext("BIT-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 = int(bit_position_str) if bit_position_str is not None else None
 
         return Parameter(
+            sdgs=sdgs,
+            semantic=semantic,
             oid=oid,
             byte_position=byte_position,
             bit_position=bit_position,
-            semantic=semantic,
-            sdgs=sdgs,
             **kwargs)
 
     def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
@@ -90,37 +116,9 @@ class Parameter(NamedElement):
         for sdg in self.sdgs:
             sdg._resolve_snrefs(context)
 
-    @property
-    def parameter_type(self) -> ParameterType:
-        raise NotImplementedError(
-            ".parameter_type is not implemented by the concrete parameter class")
-
     def get_static_bit_length(self) -> Optional[int]:
         return None
 
-    @property
-    def is_required(self) -> bool:
-        """True if the parameter must be explicitly specified when
-        encoding a message.
-
-        Required parameters are always settable, and parameters which
-        have a default value are settable but not required to be
-        specified.
-
-        """
-        raise NotImplementedError(".is_required is not implemented by the concrete parameter class")
-
-    @property
-    def is_settable(self) -> bool:
-        """True if the parameter can be specified when encoding a
-        message.
-
-        Required parameters are always settable, and parameters which
-        have a default value are settable but not required to be
-        specified.
-        """
-        raise NotImplementedError(".is_settable is not implemented by the concrete parameter class")
-
     @final
     def encode_into_pdu(self, physical_value: Optional[ParameterValue],
                         encode_state: EncodeState) -> None:

odxtools/parameters/parameterwithdop.py

@@ -24,6 +24,12 @@ class ParameterWithDOP(Parameter):
     dop_ref: Optional[OdxLinkRef]
     dop_snref: Optional[str]
 
+    @property
+    def dop(self) -> DopBase:
+        """This is usually a DataObjectProperty or a Structure object"""
+
+        return self._dop
+
     @staticmethod
     @override
     def from_et(et_element: ElementTree.Element,
@@ -63,12 +69,6 @@ class ParameterWithDOP(Parameter):
             ddds = odxrequire(context.diag_layer).diag_data_dictionary_spec
             self._dop = resolve_snref(self.dop_snref, ddds.all_data_object_properties, DopBase)
 
-    @property
-    def dop(self) -> DopBase:
-        """This is usually a DataObjectProperty or a Structure object"""
-
-        return self._dop
-
     @override
     def get_static_bit_length(self) -> Optional[int]:
         if self._dop is not None:

odxtools/parameters/physicalconstantparameter.py

@@ -19,9 +19,27 @@ from .parameterwithdop import ParameterWithDOP
 
 @dataclass
 class PhysicalConstantParameter(ParameterWithDOP):
-
     physical_constant_value_raw: str
 
+    @property
+    @override
+    def parameter_type(self) -> ParameterType:
+        return "PHYS-CONST"
+
+    @property
+    @override
+    def is_required(self) -> bool:
+        return False
+
+    @property
+    @override
+    def is_settable(self) -> bool:
+        return False
+
+    @property
+    def physical_constant_value(self) -> ParameterValue:
+        return self._physical_constant_value
+
     @staticmethod
     @override
     def from_et(et_element: ElementTree.Element,
@@ -34,11 +52,6 @@ class PhysicalConstantParameter(ParameterWithDOP):
         return PhysicalConstantParameter(
             physical_constant_value_raw=physical_constant_value_raw, **kwargs)
 
-    @property
-    @override
-    def parameter_type(self) -> ParameterType:
-        return "PHYS-CONST"
-
     @override
     def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
         return super()._build_odxlinks()
@@ -58,20 +71,6 @@ class PhysicalConstantParameter(ParameterWithDOP):
         base_data_type = dop.physical_type.base_data_type
         self._physical_constant_value = base_data_type.from_string(self.physical_constant_value_raw)
 
-    @property
-    def physical_constant_value(self) -> ParameterValue:
-        return self._physical_constant_value
-
-    @property
-    @override
-    def is_required(self) -> bool:
-        return False
-
-    @property
-    @override
-    def is_settable(self) -> bool:
-        return False
-
     @override
     def _encode_positioned_into_pdu(self, physical_value: Optional[ParameterValue],
                                     encode_state: EncodeState) -> None:

odxtools/parameters/reservedparameter.py

@@ -18,17 +18,6 @@ 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:
@@ -44,6 +33,16 @@ class ReservedParameter(Parameter):
     def is_settable(self) -> bool:
         return False
 
+    @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)
+
     @override
     def get_static_bit_length(self) -> Optional[int]:
         return self.bit_length

odxtools/parameters/systemparameter.py

@@ -29,17 +29,6 @@ PREDEFINED_SYSPARAM_VALUES = [
 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:
@@ -58,6 +47,16 @@ class SystemParameter(ParameterWithDOP):
     def is_settable(self) -> bool:
         return True
 
+    @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)
+
     @override
     def _encode_positioned_into_pdu(self, physical_value: Optional[ParameterValue],
                                     encode_state: EncodeState) -> None:

odxtools/parameters/tableentryparameter.py

@@ -28,11 +28,29 @@ class TableEntryParameter(Parameter):
     target: RowFragment
     table_row_ref: OdxLinkRef
 
+    @property
+    @override
+    def parameter_type(self) -> ParameterType:
+        return "TABLE-ENTRY"
+
+    @property
+    @override
+    def is_required(self) -> bool:
+        raise NotImplementedError("TableEntryParameter.is_required is not implemented yet.")
+
+    @property
+    @override
+    def is_settable(self) -> bool:
+        raise NotImplementedError("TableEntryParameter.is_settable is not implemented yet.")
+
+    @property
+    def table_row(self) -> "TableRow":
+        return self._table_row
+
     @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_str = odxrequire(et_element.findtext("TARGET"))
@@ -54,30 +72,11 @@ class TableEntryParameter(Parameter):
         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("TableEntryParameter.is_required is not implemented yet.")
-
-    @property
-    @override
-    def is_settable(self) -> bool:
-        raise NotImplementedError("TableEntryParameter.is_settable 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
-
     @override
     def _decode_positioned_from_pdu(self, decode_state: DecodeState) -> ParameterValue:
         raise NotImplementedError("Decoding a TableEntryParameter is not implemented yet.")

odxtools/parameters/tablekeyparameter.py

@@ -38,7 +38,6 @@ class TableKeyParameter(Parameter):
     @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))
@@ -201,7 +200,6 @@ class TableKeyParameter(Parameter):
         encode_state.cursor_bit_position = 0
 
     def encode_value_into_pdu(self, encode_state: EncodeState) -> None:
-
         key_dop = self.table.key_dop
         if key_dop is None:
             odxraise(

odxtools/parameters/tablestructparameter.py

@@ -1,6 +1,6 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import Any, Dict, List, Optional, cast
+from typing import TYPE_CHECKING, Any, Dict, List, Optional, cast
 from xml.etree import ElementTree
 
 from typing_extensions import override
@@ -15,13 +15,38 @@ from ..utils import dataclass_fields_asdict
 from .parameter import Parameter, ParameterType
 from .tablekeyparameter import TableKeyParameter
 
+if TYPE_CHECKING:
+    from ..table import Table
+
 
 @dataclass
 class TableStructParameter(Parameter):
-
     table_key_ref: Optional[OdxLinkRef]
     table_key_snref: Optional[str]
 
+    @property
+    @override
+    def parameter_type(self) -> ParameterType:
+        return "TABLE-STRUCT"
+
+    @property
+    def table(self) -> "Table":
+        return self._table_key.table
+
+    @property
+    def table_key(self) -> TableKeyParameter:
+        return self._table_key
+
+    @property
+    @override
+    def is_required(self) -> bool:
+        return True
+
+    @property
+    @override
+    def is_settable(self) -> bool:
+        return True
+
     @staticmethod
     @override
     def from_et(et_element: ElementTree.Element,
@@ -41,11 +66,6 @@ class TableStructParameter(Parameter):
         if self.table_key_ref is None and self.table_key_snref is None:
             odxraise("Either table_key_ref or table_key_snref must be defined.")
 
-    @property
-    @override
-    def parameter_type(self) -> ParameterType:
-        return "TABLE-STRUCT"
-
     @override
     def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
         return super()._build_odxlinks()
@@ -65,20 +85,6 @@ class TableStructParameter(Parameter):
             self._table_key = resolve_snref(self.table_key_snref, odxrequire(context.parameters),
                                             TableKeyParameter)
 
-    @property
-    def table_key(self) -> TableKeyParameter:
-        return self._table_key
-
-    @property
-    @override
-    def is_required(self) -> bool:
-        return True
-
-    @property
-    @override
-    def is_settable(self) -> bool:
-        return True
-
     @override
     def _encode_positioned_into_pdu(self, physical_value: Optional[ParameterValue],
                                     encode_state: EncodeState) -> None:

odxtools/parameters/valueparameter.py

@@ -20,8 +20,24 @@ from .parameterwithdop import ParameterWithDOP
 class ValueParameter(ParameterWithDOP):
     physical_default_value_raw: Optional[str]
 
-    def __post_init__(self) -> None:
-        self._physical_default_value: Optional[AtomicOdxType] = None
+    @property
+    @override
+    def parameter_type(self) -> ParameterType:
+        return "VALUE"
+
+    @property
+    def physical_default_value(self) -> Optional[AtomicOdxType]:
+        return self._physical_default_value
+
+    @property
+    @override
+    def is_required(self) -> bool:
+        return self._physical_default_value is None
+
+    @property
+    @override
+    def is_settable(self) -> bool:
+        return True
 
     @staticmethod
     @override
@@ -34,10 +50,8 @@ class ValueParameter(ParameterWithDOP):
 
         return ValueParameter(physical_default_value_raw=physical_default_value_raw, **kwargs)
 
-    @property
-    @override
-    def parameter_type(self) -> ParameterType:
-        return "VALUE"
+    def __post_init__(self) -> None:
+        self._physical_default_value: Optional[AtomicOdxType] = None
 
     @override
     def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
@@ -60,20 +74,6 @@ class ValueParameter(ParameterWithDOP):
             self._physical_default_value = base_data_type.from_string(
                 self.physical_default_value_raw)
 
-    @property
-    def physical_default_value(self) -> Optional[AtomicOdxType]:
-        return self._physical_default_value
-
-    @property
-    @override
-    def is_required(self) -> bool:
-        return self._physical_default_value is None
-
-    @property
-    @override
-    def is_settable(self) -> bool:
-        return True
-
     @override
     def _encode_positioned_into_pdu(self, physical_value: Optional[ParameterValue],
                                     encode_state: EncodeState) -> None:

odxtools/parentref.py

@@ -37,6 +37,12 @@ class ParentRef:
                                           "NOT-INHERITED-DIAG-COMM/"
                                           "DIAG-COMM-SNREF")
         ]
+        not_inherited_variables = [
+            odxrequire(el.get("SHORT-NAME"))
+            for el in et_element.iterfind("NOT-INHERITED-VARIABLES/"
+                                          "NOT-INHERITED-VARIABLE/"
+                                          "DIAG-VARIABLE-SNREF")
+        ]
         not_inherited_dops = [
             odxrequire(el.get("SHORT-NAME")) for el in et_element.iterfind("NOT-INHERITED-DOPS/"
                                                                            "NOT-INHERITED-DOP/"
@@ -47,13 +53,6 @@ class ParentRef:
                                                                            "NOT-INHERITED-TABLE/"
                                                                            "TABLE-SNREF")
         ]
-        not_inherited_variables = [
-            odxrequire(el.get("SHORT-NAME"))
-            for el in et_element.iterfind("NOT-INHERITED-VARIABLES/"
-                                          "NOT-INHERITED-VARIABLE/"
-                                          "DIAG-VARIABLE-SNREF")
-        ]
-
         not_inherited_global_neg_responses = [
             odxrequire(el.get("SHORT-NAME"))
             for el in et_element.iterfind("NOT-INHERITED-GLOBAL-NEG-RESPONSES/"

odxtools/physicaldimension.py

@@ -1,6 +1,6 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import Any, Dict, List
+from typing import Any, Dict, List, Optional
 from xml.etree import ElementTree
 
 from .element import IdentifiableElement
@@ -41,24 +41,24 @@ class PhysicalDimension(IdentifiableElement):
     )
     ```
     """
-    length_exp: int
-    mass_exp: int
-    time_exp: int
-    current_exp: int
-    temperature_exp: int
-    molar_amount_exp: int
-    luminous_intensity_exp: int
+    length_exp: Optional[int]
+    mass_exp: Optional[int]
+    time_exp: Optional[int]
+    current_exp: Optional[int]
+    temperature_exp: Optional[int]
+    molar_amount_exp: Optional[int]
+    luminous_intensity_exp: Optional[int]
 
     @staticmethod
     def from_et(et_element: ElementTree.Element,
                 doc_frags: List[OdxDocFragment]) -> "PhysicalDimension":
         kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, doc_frags))
 
-        def read_optional_int(element: ElementTree.Element, name: str) -> int:
-            if val_str := element.findtext(name):
+        def read_optional_int(element: ElementTree.Element, name: str) -> Optional[int]:
+            if (val_str := element.findtext(name)) is not None:
                 return int(val_str)
             else:
-                return 0
+                return None
 
         length_exp = read_optional_int(et_element, "LENGTH-EXP")
         mass_exp = read_optional_int(et_element, "MASS-EXP")

odxtools/physicaltype.py

@@ -39,6 +39,11 @@ class PhysicalType:
     PhysicalType(DataType.A_FLOAT64, precision=2)
     """
 
+    precision: Optional[int]
+    """Number of digits after the decimal point to display to the user
+    The precision is only applicable if the base data type is A_FLOAT32 or A_FLOAT64.
+    """
+
     base_data_type: DataType
 
     display_radix: Optional[Radix]
@@ -46,18 +51,11 @@ class PhysicalType:
     The display radix is only applicable if the base data type is A_UINT32.
     """
 
-    precision: Optional[int]
-    """Number of digits after the decimal point to display to the user
-    The precision is only applicable if the base data type is A_FLOAT32 or A_FLOAT64.
-    """
-
-    def __post_init__(self) -> None:
-        self.base_data_type = DataType(self.base_data_type)
-        if self.display_radix is not None:
-            self.display_radix = Radix(self.display_radix)
-
     @staticmethod
     def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "PhysicalType":
+        precision_str = et_element.findtext("PRECISION")
+        precision = int(precision_str) if precision_str is not None else None
+
         base_data_type_str = et_element.get("BASE-DATA-TYPE")
         if base_data_type_str not in DataType.__members__:
             odxraise(f"Encountered unknown base data type '{base_data_type_str}'")
@@ -71,8 +69,5 @@ class PhysicalType:
         else:
             display_radix = None
 
-        precision_str = et_element.findtext("PRECISION")
-        precision = int(precision_str) if precision_str is not None else None
-
         return PhysicalType(
-            base_data_type=base_data_type, display_radix=display_radix, precision=precision)
+            precision=precision, base_data_type=base_data_type, display_radix=display_radix)