odxtools 9.6.1__py3-none-any.whl → 10.0.0__py3-none-any.whl

odxtools/specialdatagroupcaption.py

@@ -1,6 +1,6 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import Any, Dict, List
+from typing import Any
 from xml.etree import ElementTree
 
 from .element import IdentifiableElement
@@ -14,12 +14,12 @@ class SpecialDataGroupCaption(IdentifiableElement):
 
     @staticmethod
     def from_et(et_element: ElementTree.Element,
-                doc_frags: List[OdxDocFragment]) -> "SpecialDataGroupCaption":
+                doc_frags: list[OdxDocFragment]) -> "SpecialDataGroupCaption":
         kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, doc_frags))
 
         return SpecialDataGroupCaption(**kwargs)
 
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         result = {self.odx_id: self}
 
         result[self.odx_id] = self

odxtools/standardizationlevel.py

@@ -0,0 +1,9 @@
+# SPDX-License-Identifier: MIT
+from enum import Enum
+
+
+class StandardizationLevel(Enum):
+    STANDARD = "STANDARD"
+    OEM_SPECIFIC = "OEM-SPECIFIC"
+    OPTIONAL = "OPTIONAL"
+    OEM_OPTIONAL = "OEM-OPTIONAL"

odxtools/standardlengthtype.py

@@ -1,6 +1,6 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import List, Literal, Optional
+from typing import Literal
 from xml.etree import ElementTree
 
 from typing_extensions import override
@@ -11,15 +11,15 @@ from .encodestate import EncodeState
 from .exceptions import odxassert, odxraise, odxrequire
 from .odxlink import OdxDocFragment
 from .odxtypes import AtomicOdxType, BytesTypes, DataType, odxstr_to_bool
-from .utils import dataclass_fields_asdict
+from .utils import dataclass_fields_asdict, read_hex_binary
 
 
-@dataclass
+@dataclass(kw_only=True)
 class StandardLengthType(DiagCodedType):
 
     bit_length: int
-    bit_mask: Optional[int]
-    is_condensed_raw: Optional[bool]
+    bit_mask: int | None = None
+    is_condensed_raw: bool | None = None
 
     @property
     def dct_type(self) -> DctType:
@@ -32,20 +32,11 @@ class StandardLengthType(DiagCodedType):
     @staticmethod
     @override
     def from_et(et_element: ElementTree.Element,
-                doc_frags: List[OdxDocFragment]) -> "StandardLengthType":
+                doc_frags: list[OdxDocFragment]) -> "StandardLengthType":
         kwargs = dataclass_fields_asdict(DiagCodedType.from_et(et_element, doc_frags))
 
         bit_length = int(odxrequire(et_element.findtext("BIT-LENGTH")))
-        bit_mask = None
-        if (bit_mask_str := et_element.findtext("BIT-MASK")) is not None:
-            # The XSD uses the type xsd:hexBinary
-            # xsd:hexBinary allows for leading/trailing whitespace, empty strings, and it only allows an even
-            # number of hex digits, while some of the examples shown in the  ODX specification exhibit an
-            # odd number of hex digits.
-            # This causes a validation paradox, so we try to be flexible
-            bit_mask_str = bit_mask_str.strip()
-            if len(bit_mask_str):
-                bit_mask = int(bit_mask_str, 16)
+        bit_mask = read_hex_binary(et_element.find("BIT-MASK"))
         is_condensed_raw = odxstr_to_bool(et_element.get("IS-CONDENSED"))
 
         return StandardLengthType(
@@ -59,7 +50,7 @@ class StandardLengthType(DiagCodedType):
                 'Can not apply a bit_mask on a value of type {self.base_data_type}',
             )
 
-    def __get_used_mask(self, internal_value: AtomicOdxType) -> Optional[bytes]:
+    def __get_used_mask(self, internal_value: AtomicOdxType) -> bytes | None:
         """Returns a byte field where all bits that are used by the
         DiagCoded type are set and all unused ones are not set.
 
@@ -127,7 +118,7 @@ class StandardLengthType(DiagCodedType):
                 mask_bit += 1
 
             if isinstance(internal_value, BytesTypes):
-                return result.to_bytes(len(internal_value), 'big')
+                return result.to_bytes(len(bytes(internal_value)), 'big')
 
             return result
 
@@ -165,7 +156,7 @@ class StandardLengthType(DiagCodedType):
                 mask_bit += 1
 
             if isinstance(raw_value, BytesTypes):
-                return result.to_bytes(len(raw_value), 'big')
+                return result.to_bytes(len(bytes(raw_value)), 'big')
 
             return result
         if isinstance(raw_value, int):
@@ -173,12 +164,12 @@ class StandardLengthType(DiagCodedType):
         if isinstance(raw_value, BytesTypes):
             int_value = int.from_bytes(raw_value, 'big')
             int_value &= self.bit_mask
-            return int_value.to_bytes(len(raw_value), 'big')
+            return int_value.to_bytes(len(bytes(raw_value)), 'big')
 
         odxraise(f'Can not apply a bit_mask on a value of type {type(raw_value)}')
         return raw_value
 
-    def get_static_bit_length(self) -> Optional[int]:
+    def get_static_bit_length(self) -> int | None:
         if self.bit_mask is not None and self.is_condensed:
             # TODO: this is pretty slow. replace it by
             # `self.bit_mask.bit_count()` once we require python >=

odxtools/state.py

@@ -1,6 +1,6 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import Any, Dict, List
+from typing import Any
 from xml.etree import ElementTree
 
 from .element import IdentifiableElement
@@ -16,12 +16,12 @@ class State(IdentifiableElement):
     """
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "State":
+    def from_et(et_element: ElementTree.Element, doc_frags: list[OdxDocFragment]) -> "State":
         kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, doc_frags))
 
         return State(**kwargs)
 
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         return {self.odx_id: self}
 
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:

odxtools/statechart.py

@@ -1,6 +1,6 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import Any, Dict, List
+from typing import Any
 from xml.etree import ElementTree
 
 from .element import IdentifiableElement
@@ -19,7 +19,7 @@ class StateChart(IdentifiableElement):
     Corresponds to STATE-CHART.
     """
     semantic: str
-    state_transitions: List[StateTransition]
+    state_transitions: list[StateTransition]
     start_state_snref: str
     states: NamedItemList[State]
 
@@ -28,7 +28,7 @@ class StateChart(IdentifiableElement):
         return self._start_state
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "StateChart":
+    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"))
@@ -52,7 +52,7 @@ class StateChart(IdentifiableElement):
             states=NamedItemList(states),
             **kwargs)
 
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         odxlinks = {self.odx_id: self}
 
         for strans in self.state_transitions:

odxtools/statemachine.py

@@ -1,6 +1,7 @@
 # SPDX-License-Identifier: MIT
+from collections.abc import Generator
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Generator, Union
+from typing import TYPE_CHECKING, Any
 
 from .exceptions import odxraise
 from .odxtypes import ParameterValueDict
@@ -97,7 +98,7 @@ class StateMachine:
         self._active_state = state_chart.start_state
 
     def execute(self, service: "DiagService", **service_params: Any
-               ) -> Generator[bytes, Union[bytes, bytearray, ParameterValueDict], None]:
+               ) -> Generator[bytes, bytes | bytearray | ParameterValueDict, None]:
         """Run a diagnostic service and update the state machine
         depending on the outcome.
 
@@ -159,7 +160,7 @@ class StateMachine:
 
         if raw_resp is None:
             raise RuntimeError("The calling code must send back a reply")
-        elif isinstance(raw_resp, (bytes, bytearray)):
+        elif isinstance(raw_resp, bytes | bytearray):
             for decoded_resp_msg in self.diag_layer.decode_response(raw_resp, raw_req):
                 for stransref in service.state_transition_refs:
                     # we only execute the first applicable state

odxtools/statetransition.py

@@ -1,30 +1,17 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import Any, Dict, List, Optional
+from typing import Any
 from xml.etree import ElementTree
 
 from .element import IdentifiableElement
 from .exceptions import odxrequire
+from .externalaccessmethod import ExternalAccessMethod
 from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, resolve_snref
 from .snrefcontext import SnRefContext
 from .state import State
 from .utils import dataclass_fields_asdict
 
 
-@dataclass
-class ExternalAccessMethod(IdentifiableElement):
-    method: str
-
-    @staticmethod
-    def from_et(et_element: ElementTree.Element,
-                doc_frags: List[OdxDocFragment]) -> "ExternalAccessMethod":
-        kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, doc_frags))
-
-        method = odxrequire(et_element.findtext("METHOD"))
-
-        return ExternalAccessMethod(method=method, **kwargs)
-
-
 @dataclass
 class StateTransition(IdentifiableElement):
     """
@@ -32,7 +19,7 @@ class StateTransition(IdentifiableElement):
     """
     source_snref: str
     target_snref: str
-    external_access_method: Optional[ExternalAccessMethod]
+    external_access_method: ExternalAccessMethod | None
 
     @property
     def source_state(self) -> State:
@@ -44,7 +31,7 @@ class StateTransition(IdentifiableElement):
 
     @staticmethod
     def from_et(et_element: ElementTree.Element,
-                doc_frags: List[OdxDocFragment]) -> "StateTransition":
+                doc_frags: list[OdxDocFragment]) -> "StateTransition":
 
         kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, doc_frags))
 
@@ -63,7 +50,7 @@ class StateTransition(IdentifiableElement):
             external_access_method=external_access_method,
             **kwargs)
 
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         return {self.odx_id: self}
 
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:

odxtools/statetransitionref.py

@@ -1,6 +1,6 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Dict, List, Optional, Tuple, Union
+from typing import TYPE_CHECKING, Any, Union
 from xml.etree import ElementTree
 
 from .basicstructure import BasicStructure
@@ -27,11 +27,11 @@ if TYPE_CHECKING:
 
 
 def _resolve_in_param(
-    in_param_if_snref: Optional[str],
-    in_param_if_snpathref: Optional[str],
-    params: List[Parameter],
+    in_param_if_snref: str | None,
+    in_param_if_snpathref: str | None,
+    params: list[Parameter],
     param_dict: ParameterValueDict,
-) -> Tuple[Optional[Parameter], Optional[ParameterValue]]:
+) -> tuple[Parameter | None, ParameterValue | None]:
 
     if in_param_if_snref is not None:
         path_chunks = [in_param_if_snref]
@@ -44,10 +44,10 @@ def _resolve_in_param(
 
 
 def _resolve_in_param_helper(
-    params: List[Parameter],
+    params: list[Parameter],
     param_dict: ParameterValueDict,
-    path_chunks: List[str],
-) -> Tuple[Optional[Parameter], Optional[ParameterValue]]:
+    path_chunks: list[str],
+) -> tuple[Parameter | None, ParameterValue | None]:
 
     inner_param = resolve_snref(path_chunks[0], params, Parameter, lenient=True)
     if inner_param is None:
@@ -90,7 +90,7 @@ def _resolve_in_param_helper(
 
 def _check_applies(ref: Union["StateTransitionRef",
                               "PreConditionStateRef"], state_machine: "StateMachine",
-                   params: List[Parameter], param_value_dict: ParameterValueDict) -> bool:
+                   params: list[Parameter], param_value_dict: ParameterValueDict) -> bool:
     if state_machine.active_state != ref.state:
         # if the active state of the state machine is not the
         # specified one, the precondition does not apply
@@ -108,13 +108,13 @@ def _check_applies(ref: Union["StateTransitionRef",
         return False
     elif not isinstance(
             param,
-        (CodedConstParameter, PhysicalConstantParameter, TableKeyParameter, ValueParameter)):
+            CodedConstParameter | PhysicalConstantParameter | TableKeyParameter | ValueParameter):
         # see checker rule 194 in section B.2 of the spec
         odxraise(f"Parameter referenced by state transition ref is of "
                  f"invalid type {type(param).__name__}")
         return False
-    elif isinstance(param, (CodedConstParameter, PhysicalConstantParameter,
-                            TableKeyParameter)) and ref.value is not None:
+    elif isinstance(param, CodedConstParameter | PhysicalConstantParameter
+                    | TableKeyParameter) and ref.value is not None:
         # see checker rule 193 in section B.2 of the spec. Why can
         # no values for constant parameters be specified? (This
         # seems to be rather inconvenient...)
@@ -155,10 +155,10 @@ class StateTransitionRef(OdxLinkRef):
     may also be conditional on the observed response of the ECU.
 
     """
-    value: Optional[str]
+    value: str | None
 
-    in_param_if_snref: Optional[str]
-    in_param_if_snpathref: Optional[str]
+    in_param_if_snref: str | None
+    in_param_if_snpathref: str | None
 
     @property
     def state_transition(self) -> StateTransition:
@@ -171,7 +171,7 @@ class StateTransitionRef(OdxLinkRef):
     @staticmethod
     def from_et(  # type: ignore[override]
             et_element: ElementTree.Element,
-            doc_frags: List[OdxDocFragment]) -> "StateTransitionRef":
+            doc_frags: list[OdxDocFragment]) -> "StateTransitionRef":
         kwargs = dataclass_fields_asdict(OdxLinkRef.from_et(et_element, doc_frags))
 
         value = et_element.findtext("VALUE")
@@ -195,7 +195,7 @@ class StateTransitionRef(OdxLinkRef):
             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]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         return {}
 
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
@@ -204,7 +204,7 @@ class StateTransitionRef(OdxLinkRef):
     def _resolve_snrefs(self, context: SnRefContext) -> None:
         pass
 
-    def execute(self, state_machine: StateMachine, params: List[Parameter],
+    def execute(self, state_machine: StateMachine, params: list[Parameter],
                 param_value_dict: ParameterValueDict) -> bool:
         """Update a StateMachine object if the state transition ought
         to be executed based on the response received after executing a

odxtools/staticfield.py

@@ -1,6 +1,7 @@
 # SPDX-License-Identifier: MIT
+from collections.abc import Sequence
 from dataclasses import dataclass
-from typing import Any, Dict, List, Sequence
+from typing import Any
 from xml.etree import ElementTree
 
 from typing_extensions import override
@@ -23,7 +24,7 @@ class StaticField(Field):
 
     @staticmethod
     @override
-    def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "StaticField":
+    def from_et(et_element: ElementTree.Element, doc_frags: list[OdxDocFragment]) -> "StaticField":
         kwargs = dataclass_fields_asdict(Field.from_et(et_element, doc_frags))
 
         fixed_number_of_items = int(odxrequire(et_element.findtext('FIXED-NUMBER-OF-ITEMS')))
@@ -33,7 +34,7 @@ class StaticField(Field):
             fixed_number_of_items=fixed_number_of_items, item_byte_size=item_byte_size, **kwargs)
 
     @override
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         odxlinks = super()._build_odxlinks()
         return odxlinks
 
@@ -89,7 +90,7 @@ class StaticField(Field):
         orig_origin = decode_state.origin_byte_position
         decode_state.origin_byte_position = decode_state.cursor_byte_position
 
-        result: List[ParameterValue] = []
+        result: list[ParameterValue] = []
         for _ in range(self.fixed_number_of_items):
             orig_cursor = decode_state.cursor_byte_position
 

odxtools/structure.py

@@ -1,6 +1,5 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import List, Optional
 from xml.etree import ElementTree
 
 from .basicstructure import BasicStructure
@@ -11,14 +10,14 @@ from .utils import dataclass_fields_asdict
 
 @dataclass
 class Structure(BasicStructure):
-    is_visible_raw: Optional[bool]
+    is_visible_raw: bool | None
 
     @property
     def is_visible(self) -> bool:
         return self.is_visible_raw in (True, None)
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "Structure":
+    def from_et(et_element: ElementTree.Element, doc_frags: list[OdxDocFragment]) -> "Structure":
         """Read a STRUCTURE element from XML."""
         kwargs = dataclass_fields_asdict(BasicStructure.from_et(et_element, doc_frags))