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

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)

odxtools/preconditionstateref.py

@@ -0,0 +1,85 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any, Dict, List, Optional
+from xml.etree import ElementTree
+
+from .exceptions import odxassert, odxrequire
+from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef
+from .odxtypes import ParameterValueDict
+from .parameters.parameter import Parameter
+from .snrefcontext import SnRefContext
+from .state import State
+from .statetransitionref import _check_applies
+from .utils import dataclass_fields_asdict
+
+if TYPE_CHECKING:
+    from .statemachine import StateMachine
+
+
+@dataclass
+class PreConditionStateRef(OdxLinkRef):
+    """
+    This class represents the PRE-CONDITION-STATE-REF XML tag.
+    """
+    value: Optional[str]
+
+    in_param_if_snref: Optional[str]
+    in_param_if_snpathref: Optional[str]
+
+    @property
+    def state(self) -> "State":
+        return self._state
+
+    @staticmethod
+    def from_et(  # type: ignore[override]
+            et_element: ElementTree.Element,
+            doc_frags: List[OdxDocFragment]) -> "PreConditionStateRef":
+        kwargs = dataclass_fields_asdict(OdxLinkRef.from_et(et_element, doc_frags))
+
+        value = et_element.findtext("VALUE")
+
+        in_param_if_snref = None
+        if (in_param_if_snref_elem := et_element.find("IN-PARAM-IF-SNREF")) is not None:
+            in_param_if_snref = odxrequire(in_param_if_snref_elem.get("SHORT-NAME"))
+
+        in_param_if_snpathref = None
+        if (in_param_if_snpathref_elem := et_element.find("IN-PARAM-IF-SNPATHREF")) is not None:
+            in_param_if_snpathref = odxrequire(in_param_if_snpathref_elem.get("SHORT-NAME-PATH"))
+
+        return PreConditionStateRef(
+            value=value,
+            in_param_if_snref=in_param_if_snref,
+            in_param_if_snpathref=in_param_if_snpathref,
+            **kwargs)
+
+    def __post_init__(self) -> None:
+        if self.value is not None:
+            odxassert(self.in_param_if_snref is not None or self.in_param_if_snref is not None,
+                      "If VALUE is specified, a parameter must be referenced")
+
+    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+        return {}
+
+    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
+        self._state = odxlinks.resolve(self, State)
+
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
+        pass
+
+    def applies(self, state_machine: "StateMachine", params: List[Parameter],
+                param_value_dict: ParameterValueDict) -> bool:
+        """Given a state machine, evaluate whether the precondition is fulfilled or not
+
+        Note that the specification is unclear about what the
+        parameters are: It says "The optional VALUE together with the
+        also optional IN-PARAM-IF snref at STATE-TRANSITION-REF and
+        PRE-CONDITION-STATE-REF can be used if the STATE-TRANSITIONs
+        and pre-condition STATEs are dependent on the values of the
+        referenced PARAMs.", but it does not specify what the
+        "referenced PARAMs" are. For the state transition refs, let's
+        assume that they are the parameters of a positive response
+        received from the ECU, whilst we assume that they are the
+        parameters of the request for PRE-CONDITION-STATE-REFs.
+        """
+
+        return _check_applies(self, state_machine, params, param_value_dict)

odxtools/progcode.py

@@ -31,7 +31,6 @@ class ProgCode:
     @staticmethod
     def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "ProgCode":
         code_file = odxrequire(et_element.findtext("CODE-FILE"))
-
         encryption = et_element.findtext("ENCRYPTION")
         syntax = odxrequire(et_element.findtext("SYNTAX"))
         revision = odxrequire(et_element.findtext("REVISION"))
@@ -44,9 +43,9 @@ class ProgCode:
 
         return ProgCode(
             code_file=code_file,
+            encryption=encryption,
             syntax=syntax,
             revision=revision,
-            encryption=encryption,
             entrypoint=entrypoint,
             library_refs=library_refs,
         )

odxtools/protstack.py

@@ -19,6 +19,10 @@ class ProtStack(IdentifiableElement):
     physical_link_type: str
     comparam_subset_refs: List[OdxLinkRef]
 
+    @property
+    def comparam_subsets(self) -> NamedItemList[ComparamSubset]:
+        return self._comparam_subsets
+
     @staticmethod
     def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "ProtStack":
         kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, doc_frags))
@@ -47,7 +51,3 @@ class ProtStack(IdentifiableElement):
 
     def _resolve_snrefs(self, context: SnRefContext) -> None:
         pass
-
-    @property
-    def comparam_subsets(self) -> NamedItemList[ComparamSubset]:
-        return self._comparam_subsets

odxtools/relateddoc.py

@@ -11,20 +11,19 @@ from .xdoc import XDoc
 
 @dataclass
 class RelatedDoc:
-    description: Optional[Description]
     xdoc: Optional[XDoc]
+    description: Optional[Description]
 
     @staticmethod
     def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "RelatedDoc":
-        description = Description.from_et(et_element.find("DESC"), doc_frags)
-
         xdoc: Optional[XDoc] = None
         if (xdoc_elem := et_element.find("XDOC")) is not None:
             xdoc = XDoc.from_et(xdoc_elem, doc_frags)
+        description = Description.from_et(et_element.find("DESC"), doc_frags)
 
         return RelatedDoc(
-            description=description,
             xdoc=xdoc,
+            description=description,
         )
 
     def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:

odxtools/scaleconstr.py

@@ -35,7 +35,6 @@ class ScaleConstr:
                              value_type: DataType) -> "ScaleConstr":
         short_label = et_element.findtext("SHORT-LABEL")
         description = Description.from_et(et_element.find("DESC"), doc_frags)
-
         lower_limit = Limit.limit_from_et(
             odxrequire(et_element.find("LOWER-LIMIT")), doc_frags, value_type=value_type)
         upper_limit = Limit.limit_from_et(

odxtools/singleecujob.py

@@ -18,12 +18,16 @@ from .utils import dataclass_fields_asdict
 class SingleEcuJob(DiagComm):
     """A single ECU job is a diagnostic communication primitive.
 
-    A single ECU job is more complex than a diagnostic service and is not provided natively by the ECU.
-    In particular, the job is defined in external programs which are referenced by the attribute `.prog_codes`.
+    A single ECU job is more complex than a diagnostic service and is
+    not provided natively by the ECU.  In particular, the job is
+    defined in external programs which are referenced by the attribute
+    `.prog_codes`.
 
-    In contrast to "multiple ECU jobs", a single ECU job only does service calls to a single ECU.
+    In contrast to "multiple ECU jobs", a single ECU job only involves
+    calls to services provided by a single ECU.
 
-    Single ECU jobs are defined in section 7.3.5.7 of the ASAM MCD-2 standard.
+    Single ECU jobs are defined in section 7.3.5.7 of the ASAM MCD-2
+    standard.
     """
 
     prog_codes: List[ProgCode]

odxtools/specialdata.py

@@ -9,19 +9,11 @@ from .snrefcontext import SnRefContext
 
 @dataclass
 class SpecialData:
+    """This corresponds to the SD XML tag"""
     semantic_info: Optional[str]  # the "SI" attribute
     text_identifier: Optional[str]  # the "TI" attribute, specifies the language used
     value: str
 
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
-        return {}
-
-    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
-        pass
-
-    def _resolve_snrefs(self, context: SnRefContext) -> None:
-        pass
-
     @staticmethod
     def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "SpecialData":
         semantic_info = et_element.get("SI")
@@ -30,3 +22,12 @@ class SpecialData:
 
         return SpecialData(
             semantic_info=semantic_info, text_identifier=text_identifier, value=value)
+
+    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+        return {}
+
+    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
+        pass
+
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
+        pass

odxtools/specialdatagroup.py

@@ -11,6 +11,7 @@ from .specialdatagroupcaption import SpecialDataGroupCaption
 
 @dataclass
 class SpecialDataGroup:
+    """This corresponds to the SDG XML tag"""
     sdg_caption: Optional[SpecialDataGroupCaption]
     sdg_caption_ref: Optional[OdxLinkRef]
     values: List[Union["SpecialDataGroup", SpecialData]]

odxtools/standardlengthtype.py

@@ -10,8 +10,8 @@ from .diagcodedtype import DctType, DiagCodedType
 from .encodestate import EncodeState
 from .exceptions import odxassert, odxraise, odxrequire
 from .odxlink import OdxDocFragment
-from .odxtypes import AtomicOdxType, DataType, odxstr_to_bool
-from .utils import BytesTypes, dataclass_fields_asdict
+from .odxtypes import AtomicOdxType, BytesTypes, DataType, odxstr_to_bool
+from .utils import dataclass_fields_asdict
 
 
 @dataclass
@@ -21,6 +21,14 @@ class StandardLengthType(DiagCodedType):
     bit_mask: Optional[int]
     is_condensed_raw: Optional[bool]
 
+    @property
+    def dct_type(self) -> DctType:
+        return "STANDARD-LENGTH-TYPE"
+
+    @property
+    def is_condensed(self) -> bool:
+        return self.is_condensed_raw is True
+
     @staticmethod
     @override
     def from_et(et_element: ElementTree.Element,
@@ -43,14 +51,6 @@ class StandardLengthType(DiagCodedType):
         return StandardLengthType(
             bit_length=bit_length, bit_mask=bit_mask, is_condensed_raw=is_condensed_raw, **kwargs)
 
-    @property
-    def dct_type(self) -> DctType:
-        return "STANDARD-LENGTH-TYPE"
-
-    @property
-    def is_condensed(self) -> bool:
-        return self.is_condensed_raw is True
-
     def __post_init__(self) -> None:
         if self.bit_mask is not None:
             maskable_types = (DataType.A_UINT32, DataType.A_INT32, DataType.A_BYTEFIELD)

odxtools/statechart.py

@@ -30,6 +30,7 @@ class StateChart(IdentifiableElement):
     @staticmethod
     def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "StateChart":
         kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, doc_frags))
+
         semantic: str = odxrequire(et_element.findtext("SEMANTIC"))
 
         state_transitions = [
@@ -54,15 +55,18 @@ class StateChart(IdentifiableElement):
     def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
         odxlinks = {self.odx_id: self}
 
-        for st in self.states:
-            odxlinks.update(st._build_odxlinks())
-
         for strans in self.state_transitions:
             odxlinks.update(strans._build_odxlinks())
 
+        for st in self.states:
+            odxlinks.update(st._build_odxlinks())
+
         return odxlinks
 
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
+        for strans in self.state_transitions:
+            strans._resolve_odxlinks(odxlinks)
+
         for st in self.states:
             st._resolve_odxlinks(odxlinks)
 
@@ -77,10 +81,10 @@ class StateChart(IdentifiableElement):
         # does that mean?
         self._start_state = resolve_snref(self.start_state_snref, self.states, State)
 
-        for st in self.states:
-            st._resolve_snrefs(context)
-
         for strans in self.state_transitions:
             strans._resolve_snrefs(context)
 
+        for st in self.states:
+            st._resolve_snrefs(context)
+
         context.state_chart = None