Merge pull request #396 from nada-ben-ali/NaBe/fix_supportsbytes_check_for_py3.12

Fix SupportsBytes Behavior Change in Python 3.12

Author: andlaus

odxtools/dataobjectproperty.py

@@ -17,7 +17,7 @@
 from .physicaltype import PhysicalType
 from .snrefcontext import SnRefContext
 from .unit import Unit
-from .utils import dataclass_fields_asdict
+from .utils import BytesTypes, dataclass_fields_asdict
 
 
 @dataclass
@@ -120,7 +120,7 @@ def encode_into_pdu(self, physical_value: ParameterValue, encode_state: EncodeSt
                 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/encodestate.py

@@ -1,11 +1,12 @@
 # SPDX-License-Identifier: MIT
 import warnings
 from dataclasses import dataclass, field
-from typing import TYPE_CHECKING, Dict, List, Optional, SupportsBytes, Tuple
+from typing import TYPE_CHECKING, Dict, List, Optional, Tuple
 
 from .encoding import Encoding, get_string_encoding
 from .exceptions import EncodeError, OdxWarning, odxassert, odxraise
 from .odxtypes import AtomicOdxType, DataType, ParameterValue
+from .utils import BytesTypes
 
 try:
     import bitstruct.c as bitstruct
@@ -97,7 +98,7 @@ def emplace_atomic_value(
 
         # Deal with raw byte fields, ...
         if base_data_type == DataType.A_BYTEFIELD:
-            if not isinstance(internal_value, (bytes, bytearray, SupportsBytes)):
+            if not isinstance(internal_value, BytesTypes):
                 odxraise(f"{internal_value!r} is not a bytefield", EncodeError)
                 return
 

odxtools/matchingparameter.py

@@ -1,6 +1,6 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import Any, Dict, List, Optional, SupportsBytes, cast
+from typing import Any, Dict, List, Optional, cast
 from xml.etree import ElementTree
 
 from .diaglayers.diaglayer import DiagLayer
@@ -10,6 +10,7 @@
 from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, resolve_snref
 from .odxtypes import ParameterValue, ParameterValueDict
 from .snrefcontext import SnRefContext
+from .utils import BytesTypes
 
 
 @dataclass
@@ -104,7 +105,7 @@ def __matches(self, param_dict: ParameterValue, snpath_chunks: List[str]) -> boo
                 # allow a slight tolerance if the expected value is
                 # floating point
                 return abs(float(self.expected_value) - parameter_value) < 1e-8
-            elif isinstance(parameter_value, (bytearray, SupportsBytes)):
+            elif isinstance(parameter_value, BytesTypes):
                 return parameter_value.hex().upper() == self.expected_value.upper()
             elif isinstance(parameter_value, DiagnosticTroubleCode):
                 # TODO: what happens if non-numerical DTCs like

odxtools/minmaxlengthtype.py

@@ -10,10 +10,10 @@
 from .diagcodedtype import DctType, DiagCodedType
 from .encodestate import EncodeState
 from .encoding import get_string_encoding
-from .exceptions import DecodeError, EncodeError, odxassert, odxraise, odxrequire
+from .exceptions import (DecodeError, EncodeError, odxassert, odxraise, odxrequire)
 from .odxlink import OdxDocFragment
 from .odxtypes import AtomicOdxType, DataType
-from .utils import dataclass_fields_asdict
+from .utils import BytesTypes, dataclass_fields_asdict
 
 
 class Termination(Enum):
@@ -83,7 +83,7 @@ def __termination_sequence(self) -> bytes:
     @override
     def encode_into_pdu(self, internal_value: AtomicOdxType, encode_state: EncodeState) -> None:
 
-        if not isinstance(internal_value, (bytes, str, bytearray)):
+        if not isinstance(internal_value, (str, BytesTypes)):
             odxraise("MinMaxLengthType is currently only implemented for strings and byte arrays",
                      EncodeError)
 

odxtools/odxtypes.py

@@ -5,6 +5,7 @@
 from xml.etree import ElementTree
 
 from .exceptions import odxassert, odxraise, odxrequire
+from .utils import BytesTypes
 
 if TYPE_CHECKING:
     from odxtools.diagnostictroublecode import DiagnosticTroubleCode
@@ -135,8 +136,8 @@ def compare_odx_values(a: AtomicOdxType, b: AtomicOdxType) -> int:
 
     # bytefields are treated like long integers: to pad the shorter
     # object with zeros and treat the results like strings.
-    if isinstance(a, (bytes, bytearray)):
-        if not isinstance(b, (bytes, bytearray)):
+    if isinstance(a, BytesTypes):
+        if not isinstance(b, BytesTypes):
             odxraise()
 
         obj_len = max(len(a), len(b))
@@ -237,7 +238,7 @@ def isinstance(self, value: Any) -> bool:
             return True
         elif expected_type is float and isinstance(value, (int, float)):
             return True
-        elif self == DataType.A_BYTEFIELD and isinstance(value, (bytearray, bytes)):
+        elif self == DataType.A_BYTEFIELD and isinstance(value, BytesTypes):
             return True
         else:
             return False

odxtools/standardlengthtype.py

@@ -3,15 +3,15 @@
 from typing import List, Literal, Optional
 from xml.etree import ElementTree
 
-from typing_extensions import SupportsBytes, override
+from typing_extensions import override
 
 from .decodestate import DecodeState
 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 dataclass_fields_asdict
+from .utils import BytesTypes, dataclass_fields_asdict
 
 
 @dataclass
@@ -91,7 +91,7 @@ def __get_used_mask(self, internal_value: AtomicOdxType) -> Optional[bytes]:
             return used_mask.to_bytes((bit_sz + 7) // 8, endianness)
 
         sz: int
-        if isinstance(internal_value, (bytearray, SupportsBytes)):
+        if isinstance(internal_value, BytesTypes):
             sz = len(bytes(internal_value))
         else:
             sz = (odxrequire(self.get_static_bit_length()) + 7) // 8
@@ -107,7 +107,7 @@ def __apply_mask(self, internal_value: AtomicOdxType) -> AtomicOdxType:
 
         if self.is_condensed:
             int_value: int
-            if isinstance(internal_value, (bytearray, SupportsBytes)):
+            if isinstance(internal_value, BytesTypes):
                 int_value = int.from_bytes(internal_value, 'big')
             elif isinstance(internal_value, int):
                 int_value = internal_value
@@ -126,14 +126,14 @@ def __apply_mask(self, internal_value: AtomicOdxType) -> AtomicOdxType:
 
                 mask_bit += 1
 
-            if isinstance(internal_value, (bytearray, SupportsBytes)):
+            if isinstance(internal_value, BytesTypes):
                 return result.to_bytes(len(internal_value), 'big')
 
             return result
 
         if isinstance(internal_value, int):
             return internal_value & self.bit_mask
-        if isinstance(internal_value, (bytearray, SupportsBytes)):
+        if isinstance(internal_value, BytesTypes):
             int_value = int.from_bytes(internal_value, 'big')
             int_value &= self.bit_mask
             return int_value.to_bytes(len(bytes(internal_value)), 'big')
@@ -146,7 +146,7 @@ def __unapply_mask(self, raw_value: AtomicOdxType) -> AtomicOdxType:
             return raw_value
         if self.is_condensed:
             int_value: int
-            if isinstance(raw_value, (bytearray, SupportsBytes)):
+            if isinstance(raw_value, BytesTypes):
                 int_value = int.from_bytes(raw_value, 'big')
             elif isinstance(raw_value, int):
                 int_value = raw_value
@@ -164,16 +164,16 @@ def __unapply_mask(self, raw_value: AtomicOdxType) -> AtomicOdxType:
 
                 mask_bit += 1
 
-            if isinstance(raw_value, (bytearray, SupportsBytes)):
+            if isinstance(raw_value, BytesTypes):
                 return result.to_bytes(len(raw_value), 'big')
 
             return result
         if isinstance(raw_value, int):
             return raw_value & self.bit_mask
-        if isinstance(raw_value, (bytearray, SupportsBytes)):
+        if isinstance(raw_value, BytesTypes):
             int_value = int.from_bytes(raw_value, 'big')
             int_value &= self.bit_mask
-            return int_value
+            return int_value.to_bytes(len(raw_value), 'big')
 
         odxraise(f'Can not apply a bit_mask on a value of type {type(raw_value)}')
         return raw_value

odxtools/utils.py

@@ -3,11 +3,15 @@
 import re
 from typing import TYPE_CHECKING, Any, Dict, Optional
 
+from typing_extensions import SupportsBytes
+
 if TYPE_CHECKING:
     from .database import Database
     from .diaglayers.diaglayer import DiagLayer
     from .snrefcontext import SnRefContext
 
+BytesTypes = (bytearray, bytes, SupportsBytes)
+
 
 def retarget_snrefs(database: "Database",
                     diag_layer: "DiagLayer",