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

odxtools/dataobjectproperty.py

@@ -13,7 +13,7 @@ from .encodestate import EncodeState
 from .exceptions import EncodeError, odxraise, odxrequire
 from .internalconstr import InternalConstr
 from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef
-from .odxtypes import AtomicOdxType, ParameterValue
+from .odxtypes import AtomicOdxType, BytesTypes, ParameterValue
 from .physicaltype import PhysicalType
 from .snrefcontext import SnRefContext
 from .unit import Unit
@@ -28,21 +28,26 @@ class DataObjectProperty(DopBase):
     name would thus be SimpleDataObjectProp...
     """
 
+    #: Conversion from the physical to the internal representation and vice-versa.
+    compu_method: CompuMethod
+
     #: The type used to represent a value internally
     diag_coded_type: DiagCodedType
 
     #: The type of the value in the physical world
     physical_type: PhysicalType
 
-    #: Conversion from the physical to the internal representation and vice-versa.
-    compu_method: CompuMethod
+    internal_constr: Optional[InternalConstr]
 
     #: The unit associated with physical values (e.g. 'm/s^2')
     unit_ref: Optional[OdxLinkRef]
 
-    internal_constr: Optional[InternalConstr]
     physical_constr: Optional[InternalConstr]
 
+    @property
+    def unit(self) -> Optional[Unit]:
+        return self._unit
+
     @staticmethod
     def from_et(et_element: ElementTree.Element,
                 doc_frags: List[OdxDocFragment]) -> "DataObjectProperty":
@@ -51,7 +56,6 @@ class DataObjectProperty(DopBase):
 
         diag_coded_type = create_any_diag_coded_type_from_et(
             odxrequire(et_element.find("DIAG-CODED-TYPE")), doc_frags)
-
         physical_type = PhysicalType.from_et(
             odxrequire(et_element.find("PHYSICAL-TYPE")), doc_frags)
         compu_method = create_any_compu_method_from_et(
@@ -60,39 +64,37 @@ class DataObjectProperty(DopBase):
             internal_type=diag_coded_type.base_data_type,
             physical_type=physical_type.base_data_type,
         )
-        unit_ref = OdxLinkRef.from_et(et_element.find("UNIT-REF"), doc_frags)
-
         internal_constr = None
         if (internal_constr_elem := et_element.find("INTERNAL-CONSTR")) is not None:
             internal_constr = InternalConstr.constr_from_et(
                 internal_constr_elem, doc_frags, value_type=diag_coded_type.base_data_type)
-
+        unit_ref = OdxLinkRef.from_et(et_element.find("UNIT-REF"), doc_frags)
         physical_constr = None
         if (physical_constr_elem := et_element.find("PHYS-CONSTR")) is not None:
             physical_constr = InternalConstr.constr_from_et(
                 physical_constr_elem, doc_frags, value_type=physical_type.base_data_type)
 
         return DataObjectProperty(
+            compu_method=compu_method,
             diag_coded_type=diag_coded_type,
             physical_type=physical_type,
-            compu_method=compu_method,
-            unit_ref=unit_ref,
             internal_constr=internal_constr,
+            unit_ref=unit_ref,
             physical_constr=physical_constr,
             **kwargs)
 
     def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
         result = super()._build_odxlinks()
-        result.update(self.diag_coded_type._build_odxlinks())
         result.update(self.compu_method._build_odxlinks())
+        result.update(self.diag_coded_type._build_odxlinks())
         return result
 
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
         """Resolves the reference to the unit"""
         super()._resolve_odxlinks(odxlinks)
 
-        self.diag_coded_type._resolve_odxlinks(odxlinks)
         self.compu_method._resolve_odxlinks(odxlinks)
+        self.diag_coded_type._resolve_odxlinks(odxlinks)
 
         self._unit: Optional[Unit] = None
         if self.unit_ref:
@@ -101,12 +103,8 @@ class DataObjectProperty(DopBase):
     def _resolve_snrefs(self, context: SnRefContext) -> None:
         super()._resolve_snrefs(context)
 
-        self.diag_coded_type._resolve_snrefs(context)
         self.compu_method._resolve_snrefs(context)
-
-    @property
-    def unit(self) -> Optional[Unit]:
-        return self._unit
+        self.diag_coded_type._resolve_snrefs(context)
 
     def get_static_bit_length(self) -> Optional[int]:
         return self.diag_coded_type.get_static_bit_length()
@@ -120,7 +118,7 @@ class DataObjectProperty(DopBase):
                 f"The value {repr(physical_value)} of type {type(physical_value).__name__}"
                 f" is not a valid.")
 
-        if not isinstance(physical_value, (int, float, str, bytes, bytearray)):
+        if not isinstance(physical_value, (int, float, str, BytesTypes)):
             odxraise(f"Invalid type '{type(physical_value).__name__}' for physical value. "
                      f"(Expect atomic type!)")
         internal_value = self.compu_method.convert_physical_to_internal(physical_value)

odxtools/description.py

@@ -27,6 +27,7 @@ class ExternalDoc:
 class Description:
     text: str
     external_docs: List[ExternalDoc]
+
     text_identifier: Optional[str]
 
     @staticmethod
@@ -48,12 +49,13 @@ class Description:
 
         text = "\n".join(stripped_lines).strip()
 
-        text_identifier = et_element.get("TI")
-
         external_docs = \
             [
                 odxrequire(ExternalDoc.from_et(ed, doc_frags)) for ed in et_element.iterfind("EXTERNAL-DOCS/EXTERNAL-DOC")
             ]
+
+        text_identifier = et_element.attrib.get("TI")
+
         return Description(text=text, text_identifier=text_identifier, external_docs=external_docs)
 
     @staticmethod

odxtools/determinenumberofitems.py

@@ -18,6 +18,10 @@ class DetermineNumberOfItems:
     bit_position: Optional[int]
     dop_ref: OdxLinkRef
 
+    @property
+    def dop(self) -> DataObjectProperty:
+        return self._dop
+
     @staticmethod
     def from_et(et_element: ElementTree.Element,
                 doc_frags: List[OdxDocFragment]) -> "DetermineNumberOfItems":
@@ -40,7 +44,3 @@ class DetermineNumberOfItems:
 
     def _resolve_snrefs(self, context: SnRefContext) -> None:
         pass
-
-    @property
-    def dop(self) -> DataObjectProperty:
-        return self._dop

odxtools/diagcodedtype.py

@@ -22,21 +22,24 @@ DctType = Literal[
 
 @dataclass
 class DiagCodedType:
-
-    base_data_type: DataType
     base_type_encoding: Optional[Encoding]
+    base_data_type: DataType
+
     is_highlow_byte_order_raw: Optional[bool]
 
+    @property
+    def dct_type(self) -> DctType:
+        odxraise(f"Class {type(self).__name__} does not override required method "
+                 f"dct_type()", NotImplementedError)
+        return cast(DctType, None)
+
+    @property
+    def is_highlow_byte_order(self) -> bool:
+        return self.is_highlow_byte_order_raw in [None, True]
+
     @staticmethod
     def from_et(et_element: ElementTree.Element,
                 doc_frags: List[OdxDocFragment]) -> "DiagCodedType":
-        base_data_type_str = odxrequire(et_element.get("BASE-DATA-TYPE"))
-        try:
-            base_data_type = DataType(base_data_type_str)
-        except ValueError:
-            odxraise(f"Unknown base data type {base_data_type_str}")
-            base_data_type = cast(DataType, None)
-
         base_type_encoding = None
         if (base_type_encoding_str := et_element.get("BASE-TYPE-ENCODING")) is not None:
             try:
@@ -44,11 +47,18 @@ class DiagCodedType:
             except ValueError:
                 odxraise(f"Encountered unknown BASE-TYPE-ENCODING '{base_type_encoding_str}'")
 
+        base_data_type_str = odxrequire(et_element.get("BASE-DATA-TYPE"))
+        try:
+            base_data_type = DataType(base_data_type_str)
+        except ValueError:
+            odxraise(f"Unknown base data type {base_data_type_str}")
+            base_data_type = cast(DataType, None)
+
         is_highlow_byte_order_raw = odxstr_to_bool(et_element.get("IS-HIGHLOW-BYTE-ORDER"))
 
         return DiagCodedType(
-            base_data_type=base_data_type,
             base_type_encoding=base_type_encoding,
+            base_data_type=base_data_type,
             is_highlow_byte_order_raw=is_highlow_byte_order_raw)
 
     def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:  # noqa: B027
@@ -65,16 +75,6 @@ class DiagCodedType:
     def get_static_bit_length(self) -> Optional[int]:
         return None
 
-    @property
-    def dct_type(self) -> DctType:
-        odxraise(f"Class {type(self).__name__} does not override required method "
-                 f"dct_type()", NotImplementedError)
-        return cast(DctType, None)
-
-    @property
-    def is_highlow_byte_order(self) -> bool:
-        return self.is_highlow_byte_order_raw in [None, True]
-
     def _minimal_byte_length_of(self, internal_value: Union[bytes, str]) -> int:
         """Helper method to get the minimal byte length.
         (needed for LeadingLength- and MinMaxLengthType)

odxtools/diagcomm.py

@@ -12,10 +12,12 @@ from .functionalclass import FunctionalClass
 from .nameditemlist import NamedItemList
 from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef, resolve_snref
 from .odxtypes import odxstr_to_bool
+from .preconditionstateref import PreConditionStateRef
 from .snrefcontext import SnRefContext
 from .specialdatagroup import SpecialDataGroup
 from .state import State
 from .statetransition import StateTransition
+from .statetransitionref import StateTransitionRef
 from .utils import dataclass_fields_asdict
 
 if TYPE_CHECKING:
@@ -61,8 +63,8 @@ class DiagComm(IdentifiableElement):
     audience: Optional[Audience]
     protocol_snrefs: List[str]
     related_diag_comm_refs: List[RelatedDiagCommRef]
-    pre_condition_state_refs: List[OdxLinkRef]
-    state_transition_refs: List[OdxLinkRef]
+    pre_condition_state_refs: List[PreConditionStateRef]
+    state_transition_refs: List[StateTransitionRef]
 
     # attributes
     semantic: Optional[str]
@@ -71,6 +73,38 @@ class DiagComm(IdentifiableElement):
     is_executable_raw: Optional[bool]
     is_final_raw: Optional[bool]
 
+    @property
+    def functional_classes(self) -> NamedItemList[FunctionalClass]:
+        return self._functional_classes
+
+    @property
+    def protocols(self) -> NamedItemList["Protocol"]:
+        return self._protocols
+
+    @property
+    def related_diag_comms(self) -> NamedItemList["DiagComm"]:
+        return self._related_diag_comms
+
+    @property
+    def pre_condition_states(self) -> NamedItemList[State]:
+        return self._pre_condition_states
+
+    @property
+    def state_transitions(self) -> NamedItemList[StateTransition]:
+        return self._state_transitions
+
+    @property
+    def is_mandatory(self) -> bool:
+        return self.is_mandatory_raw is True
+
+    @property
+    def is_executable(self) -> bool:
+        return self.is_executable_raw in (None, True)
+
+    @property
+    def is_final(self) -> bool:
+        return self.is_final_raw is True
+
     @staticmethod
     def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "DiagComm":
         kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, doc_frags))
@@ -100,27 +134,27 @@ class DiagComm(IdentifiableElement):
         ]
 
         pre_condition_state_refs = [
-            odxrequire(OdxLinkRef.from_et(el, doc_frags))
+            PreConditionStateRef.from_et(el, doc_frags)
             for el in et_element.iterfind("PRE-CONDITION-STATE-REFS/PRE-CONDITION-STATE-REF")
         ]
 
         state_transition_refs = [
-            odxrequire(OdxLinkRef.from_et(el, doc_frags))
+            StateTransitionRef.from_et(el, doc_frags)
             for el in et_element.iterfind("STATE-TRANSITION-REFS/STATE-TRANSITION-REF")
         ]
 
-        semantic = et_element.get("SEMANTIC")
+        semantic = et_element.attrib.get("SEMANTIC")
 
         diagnostic_class: Optional[DiagClassType] = None
-        if (diagnostic_class_str := et_element.get("DIAGNOSTIC-CLASS")) is not None:
+        if (diagnostic_class_str := et_element.attrib.get("DIAGNOSTIC-CLASS")) is not None:
             try:
                 diagnostic_class = DiagClassType(diagnostic_class_str)
             except ValueError:
                 odxraise(f"Encountered unknown diagnostic class type '{diagnostic_class_str}'")
 
-        is_mandatory_raw = odxstr_to_bool(et_element.get("IS-MANDATORY"))
-        is_executable_raw = odxstr_to_bool(et_element.get("IS-EXECUTABLE"))
-        is_final_raw = odxstr_to_bool(et_element.get("IS-FINAL"))
+        is_mandatory_raw = odxstr_to_bool(et_element.attrib.get("IS-MANDATORY"))
+        is_executable_raw = odxstr_to_bool(et_element.attrib.get("IS-EXECUTABLE"))
+        is_final_raw = odxstr_to_bool(et_element.attrib.get("IS-FINAL"))
 
         return DiagComm(
             admin_data=admin_data,
@@ -138,38 +172,6 @@ class DiagComm(IdentifiableElement):
             is_final_raw=is_final_raw,
             **kwargs)
 
-    @property
-    def functional_classes(self) -> NamedItemList[FunctionalClass]:
-        return self._functional_classes
-
-    @property
-    def protocols(self) -> NamedItemList["Protocol"]:
-        return self._protocols
-
-    @property
-    def related_diag_comms(self) -> NamedItemList["DiagComm"]:
-        return self._related_diag_comms
-
-    @property
-    def pre_condition_states(self) -> NamedItemList[State]:
-        return self._pre_condition_states
-
-    @property
-    def state_transitions(self) -> NamedItemList[StateTransition]:
-        return self._state_transitions
-
-    @property
-    def is_mandatory(self) -> bool:
-        return self.is_mandatory_raw is True
-
-    @property
-    def is_executable(self) -> bool:
-        return self.is_executable_raw in (None, True)
-
-    @property
-    def is_final(self) -> bool:
-        return self.is_final_raw is True
-
     def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
         result = {self.odx_id: self}
 
@@ -182,6 +184,12 @@ class DiagComm(IdentifiableElement):
         if self.audience is not None:
             result.update(self.audience._build_odxlinks())
 
+        for pc_ref in self.pre_condition_state_refs:
+            result.update(pc_ref._build_odxlinks())
+
+        for st_ref in self.state_transition_refs:
+            result.update(st_ref._build_odxlinks())
+
         return result
 
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
@@ -194,6 +202,12 @@ class DiagComm(IdentifiableElement):
         for sdg in self.sdgs:
             sdg._resolve_odxlinks(odxlinks)
 
+        for pc_ref in self.pre_condition_state_refs:
+            pc_ref._resolve_odxlinks(odxlinks)
+
+        for st_ref in self.state_transition_refs:
+            st_ref._resolve_odxlinks(odxlinks)
+
         self._related_diag_comms = NamedItemList(
             [odxlinks.resolve(dc_ref, DiagComm) for dc_ref in self.related_diag_comm_refs])
         self._functional_classes = NamedItemList(
@@ -213,6 +227,12 @@ class DiagComm(IdentifiableElement):
         for sdg in self.sdgs:
             sdg._resolve_snrefs(context)
 
+        for pc_ref in self.pre_condition_state_refs:
+            pc_ref._resolve_snrefs(context)
+
+        for st_ref in self.state_transition_refs:
+            st_ref._resolve_snrefs(context)
+
         if TYPE_CHECKING:
             diag_layer = odxrequire(context.diag_layer)
             self._protocols = NamedItemList([

odxtools/diagdatadictionaryspec.py

@@ -5,7 +5,6 @@ from typing import Any, Dict, List, Optional
 from xml.etree import ElementTree
 
 from .admindata import AdminData
-from .basicstructure import BasicStructure
 from .dataobjectproperty import DataObjectProperty
 from .dopbase import DopBase
 from .dtcdop import DtcDop
@@ -14,7 +13,6 @@ from .dynamiclengthfield import DynamicLengthField
 from .endofpdufield import EndOfPduField
 from .environmentdata import EnvironmentData
 from .environmentdatadescription import EnvironmentDataDescription
-from .exceptions import odxraise
 from .multiplexer import Multiplexer
 from .nameditemlist import NamedItemList
 from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
@@ -32,7 +30,7 @@ class DiagDataDictionarySpec:
     dtc_dops: NamedItemList[DtcDop]
     env_data_descs: NamedItemList[EnvironmentDataDescription]
     data_object_props: NamedItemList[DataObjectProperty]
-    structures: NamedItemList[BasicStructure]
+    structures: NamedItemList[Structure]
     static_fields: NamedItemList[StaticField]
     dynamic_length_fields: NamedItemList[DynamicLengthField]
     dynamic_endmarker_fields: NamedItemList[DynamicEndmarkerField]
@@ -43,21 +41,6 @@ class DiagDataDictionarySpec:
     tables: NamedItemList[Table]
     sdgs: List[SpecialDataGroup]
 
-    def __post_init__(self) -> None:
-        self._all_data_object_properties: NamedItemList[DopBase] = NamedItemList(
-            chain(
-                self.dtc_dops,
-                self.env_data_descs,
-                self.data_object_props,
-                self.structures,
-                self.static_fields,
-                self.dynamic_length_fields,
-                self.dynamic_endmarker_fields,
-                self.end_of_pdu_fields,
-                self.muxs,
-                self.env_datas,
-            ))
-
     @staticmethod
     def from_et(et_element: ElementTree.Element,
                 doc_frags: List[OdxDocFragment]) -> "DiagDataDictionarySpec":
@@ -65,72 +48,70 @@ class DiagDataDictionarySpec:
         if (admin_data_elem := et_element.find("ADMIN-DATA")) is not None:
             admin_data = AdminData.from_et(admin_data_elem, doc_frags)
 
-        dtc_dops = []
-        for dtc_dop_elem in et_element.iterfind("DTC-DOPS/DTC-DOP"):
-            dtc_dop = DtcDop.from_et(dtc_dop_elem, doc_frags)
-            if not isinstance(dtc_dop, DtcDop):
-                odxraise()
-            dtc_dops.append(dtc_dop)
+        dtc_dops = NamedItemList([
+            DtcDop.from_et(dtc_dop_elem, doc_frags)
+            for dtc_dop_elem in et_element.iterfind("DTC-DOPS/DTC-DOP")
+        ])
 
-        env_data_descs = [
+        env_data_descs = NamedItemList([
             EnvironmentDataDescription.from_et(env_data_desc_element, doc_frags)
             for env_data_desc_element in et_element.iterfind("ENV-DATA-DESCS/ENV-DATA-DESC")
-        ]
+        ])
 
-        data_object_props = [
+        data_object_props = NamedItemList([
             DataObjectProperty.from_et(dop_element, doc_frags)
             for dop_element in et_element.iterfind("DATA-OBJECT-PROPS/DATA-OBJECT-PROP")
-        ]
+        ])
 
-        structures = [
+        structures = NamedItemList([
             Structure.from_et(structure_element, doc_frags)
             for structure_element in et_element.iterfind("STRUCTURES/STRUCTURE")
-        ]
+        ])
 
-        static_fields = [
+        static_fields = NamedItemList([
             StaticField.from_et(dl_element, doc_frags)
             for dl_element in et_element.iterfind("STATIC-FIELDS/STATIC-FIELD")
-        ]
+        ])
 
-        dynamic_length_fields = [
+        dynamic_length_fields = NamedItemList([
             DynamicLengthField.from_et(dl_element, doc_frags)
             for dl_element in et_element.iterfind("DYNAMIC-LENGTH-FIELDS/DYNAMIC-LENGTH-FIELD")
-        ]
+        ])
 
-        dynamic_endmarker_fields = [
+        dynamic_endmarker_fields = NamedItemList([
             DynamicEndmarkerField.from_et(dl_element, doc_frags) for dl_element in
             et_element.iterfind("DYNAMIC-ENDMARKER-FIELDS/DYNAMIC-ENDMARKER-FIELD")
-        ]
+        ])
 
-        end_of_pdu_fields = [
+        end_of_pdu_fields = NamedItemList([
             EndOfPduField.from_et(eofp_element, doc_frags)
             for eofp_element in et_element.iterfind("END-OF-PDU-FIELDS/END-OF-PDU-FIELD")
-        ]
+        ])
 
-        muxs = [
+        muxs = NamedItemList([
             Multiplexer.from_et(mux_element, doc_frags)
             for mux_element in et_element.iterfind("MUXS/MUX")
-        ]
+        ])
 
         env_data_elements = chain(
             et_element.iterfind("ENV-DATAS/ENV-DATA"),
             # ODX 2.0.0 says ENV-DATA-DESC could contain a list of ENV-DATAS
             et_element.iterfind("ENV-DATA-DESCS/ENV-DATA-DESC/ENV-DATAS/ENV-DATA"),
         )
-        env_datas = [
+        env_datas = NamedItemList([
             EnvironmentData.from_et(env_data_element, doc_frags)
             for env_data_element in env_data_elements
-        ]
+        ])
 
         if (spec_elem := et_element.find("UNIT-SPEC")) is not None:
             unit_spec = UnitSpec.from_et(spec_elem, doc_frags)
         else:
             unit_spec = None
 
-        tables = [
+        tables = NamedItemList([
             Table.from_et(table_element, doc_frags)
             for table_element in et_element.iterfind("TABLES/TABLE")
-        ]
+        ])
 
         sdgs = [
             SpecialDataGroup.from_et(sdge, doc_frags) for sdge in et_element.iterfind("SDGS/SDG")
@@ -138,21 +119,36 @@ class DiagDataDictionarySpec:
 
         return DiagDataDictionarySpec(
             admin_data=admin_data,
-            dtc_dops=NamedItemList(dtc_dops),
-            env_data_descs=NamedItemList(env_data_descs),
-            data_object_props=NamedItemList(data_object_props),
-            structures=NamedItemList(structures),
-            static_fields=NamedItemList(static_fields),
-            dynamic_length_fields=NamedItemList(dynamic_length_fields),
-            dynamic_endmarker_fields=NamedItemList(dynamic_endmarker_fields),
-            end_of_pdu_fields=NamedItemList(end_of_pdu_fields),
-            muxs=NamedItemList(muxs),
-            env_datas=NamedItemList(env_datas),
+            dtc_dops=dtc_dops,
+            env_data_descs=env_data_descs,
+            data_object_props=data_object_props,
+            structures=structures,
+            static_fields=static_fields,
+            dynamic_length_fields=dynamic_length_fields,
+            dynamic_endmarker_fields=dynamic_endmarker_fields,
+            end_of_pdu_fields=end_of_pdu_fields,
+            muxs=muxs,
+            env_datas=env_datas,
             unit_spec=unit_spec,
-            tables=NamedItemList(tables),
+            tables=tables,
             sdgs=sdgs,
         )
 
+    def __post_init__(self) -> None:
+        self._all_data_object_properties: NamedItemList[DopBase] = NamedItemList(
+            chain(
+                self.dtc_dops,
+                self.env_data_descs,
+                self.data_object_props,
+                self.structures,
+                self.static_fields,
+                self.dynamic_length_fields,
+                self.dynamic_endmarker_fields,
+                self.end_of_pdu_fields,
+                self.muxs,
+                self.env_datas,
+            ))
+
     def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
         # note that DataDictionarySpec objects do not exhibit an ODXLINK id.
         odxlinks = {}