Revert "Improve typing (#238)"

This reverts commit cc8d776.

Author: mdabrowski1990

tests/software_tests/can/test_extended_addressing_information.py

@@ -71,7 +71,7 @@ def test_validate_packet_ai__valid(self, addressing_type, can_id, target_address
                                                                    can_id=can_id,
                                                                    target_address=target_address) == {
             AbstractCanAddressingInformation.ADDRESSING_FORMAT_NAME: CanAddressingFormat.EXTENDED_ADDRESSING,
-            AbstractCanAddressingInformation.ADDRESSING_TYPE_NAME: self.mock_validate_addressing_type.return_value,
+            AbstractCanAddressingInformation.ADDRESSING_TYPE_NAME: addressing_type,
             AbstractCanAddressingInformation.CAN_ID_NAME: can_id,
             AbstractCanAddressingInformation.TARGET_ADDRESS_NAME: target_address,
             AbstractCanAddressingInformation.SOURCE_ADDRESS_NAME: None,

tests/software_tests/can/test_normal_addressing_information.py

@@ -66,7 +66,7 @@ def test_validate_packet_ai__valid(self, addressing_type, can_id):
         assert Normal11BitCanAddressingInformation.validate_packet_ai(addressing_type=addressing_type,
                                                                       can_id=can_id) == {
                    AbstractCanAddressingInformation.ADDRESSING_FORMAT_NAME: CanAddressingFormat.NORMAL_11BIT_ADDRESSING,
-                   AbstractCanAddressingInformation.ADDRESSING_TYPE_NAME: self.mock_validate_addressing_type.return_value,
+                   AbstractCanAddressingInformation.ADDRESSING_TYPE_NAME: addressing_type,
                    AbstractCanAddressingInformation.CAN_ID_NAME: can_id,
                    AbstractCanAddressingInformation.TARGET_ADDRESS_NAME: None,
                    AbstractCanAddressingInformation.SOURCE_ADDRESS_NAME: None,
@@ -159,7 +159,7 @@ def test_validate_packet_ai__valid_without_can_id(self, addressing_type, target_
                                                                       target_address=target_address,
                                                                       source_address=source_address) == {
             AbstractCanAddressingInformation.ADDRESSING_FORMAT_NAME: CanAddressingFormat.NORMAL_FIXED_ADDRESSING,
-            AbstractCanAddressingInformation.ADDRESSING_TYPE_NAME: self.mock_validate_addressing_type.return_value,
+            AbstractCanAddressingInformation.ADDRESSING_TYPE_NAME: addressing_type,
             AbstractCanAddressingInformation.CAN_ID_NAME: self.mock_can_id_handler_class.encode_normal_fixed_addressed_can_id.return_value,
             AbstractCanAddressingInformation.TARGET_ADDRESS_NAME: target_address,
             AbstractCanAddressingInformation.SOURCE_ADDRESS_NAME: source_address,
@@ -170,7 +170,7 @@ def test_validate_packet_ai__valid_without_can_id(self, addressing_type, target_
         self.mock_can_id_handler_class.validate_can_id.assert_not_called()
         self.mock_can_id_handler_class.decode_normal_fixed_addressed_can_id.assert_not_called()
         self.mock_can_id_handler_class.encode_normal_fixed_addressed_can_id.assert_called_once_with(
-            addressing_type=self.mock_validate_addressing_type.return_value,
+            addressing_type=addressing_type,
             target_address=target_address,
             source_address=source_address
         )
@@ -187,7 +187,7 @@ def test_validate_packet_ai__valid_with_can_id(self, addressing_type, can_id, ta
         decoded_target_address = target_address or "ta"
         decoded_source_address = source_address or "sa"
         self.mock_can_id_handler_class.decode_normal_fixed_addressed_can_id.return_value = {
-            self.mock_can_id_handler_class.ADDRESSING_TYPE_NAME: self.mock_validate_addressing_type.return_value,
+            self.mock_can_id_handler_class.ADDRESSING_TYPE_NAME: addressing_type,
             self.mock_can_id_handler_class.TARGET_ADDRESS_NAME: decoded_target_address,
             self.mock_can_id_handler_class.SOURCE_ADDRESS_NAME: decoded_source_address,
         }
@@ -196,7 +196,7 @@ def test_validate_packet_ai__valid_with_can_id(self, addressing_type, can_id, ta
                                                                       target_address=target_address,
                                                                       source_address=source_address) == {
             AbstractCanAddressingInformation.ADDRESSING_FORMAT_NAME: CanAddressingFormat.NORMAL_FIXED_ADDRESSING,
-            AbstractCanAddressingInformation.ADDRESSING_TYPE_NAME: self.mock_validate_addressing_type.return_value,
+            AbstractCanAddressingInformation.ADDRESSING_TYPE_NAME: addressing_type,
             AbstractCanAddressingInformation.CAN_ID_NAME: can_id,
             AbstractCanAddressingInformation.TARGET_ADDRESS_NAME: decoded_target_address,
             AbstractCanAddressingInformation.SOURCE_ADDRESS_NAME: decoded_source_address,

tests/software_tests/packet/test_can_packet_type.py

@@ -24,12 +24,10 @@ def test_inheritance__abstract_packet_type(self):
 
     @pytest.mark.parametrize("value", [2, 3, CanPacketType.CONSECUTIVE_FRAME, CanPacketType.FLOW_CONTROL])
     def test_is_initial_packet_type__false(self, value):
-        self.mock_validate_member.side_effect = lambda arg: arg
         assert CanPacketType.is_initial_packet_type(value) is False
         self.mock_validate_member.assert_called_once_with(value)
 
     @pytest.mark.parametrize("value", [0, 1, CanPacketType.FIRST_FRAME, CanPacketType.SINGLE_FRAME])
     def test_is_initial_packet_type__true(self, value):
-        self.mock_validate_member.side_effect = lambda arg: arg
         assert CanPacketType.is_initial_packet_type(value) is True
         self.mock_validate_member.assert_called_once_with(value)

tests/software_tests/utilities/test_bytes_operations.py

@@ -40,7 +40,6 @@ def teardown_method(self):
         ([0x98, 0x76, 0x54, 0x32, 0x1F], Endianness.LITTLE_ENDIAN, 0x1F32547698),
     ])
     def test_bytes_list_to_int(self, bytes_list, endianness, expected_output):
-        self.mock_validate_endianness.side_effect = lambda arg: arg
         assert bytes_list_to_int(bytes_list=bytes_list, endianness=endianness) == expected_output
         self.mock_validate_raw_bytes.assert_called_once_with(bytes_list)
         self.mock_validate_endianness.assert_called_once_with(endianness)

uds/can/addressing_information.py

@@ -137,12 +137,12 @@ def decode_packet_ai(cls,
         """
         from_data_bytes = cls.decode_ai_data_bytes(addressing_format=addressing_format, ai_data_bytes=ai_data_bytes)
         from_can_id = CanIdHandler.decode_can_id(addressing_format=addressing_format, can_id=can_id)
-        return cls.DecodedAIParamsAlias(
-            addressing_type=from_can_id.get(AbstractCanAddressingInformation.ADDRESSING_TYPE_NAME, None),  # type: ignore  # noqa: E501
-            target_address=from_data_bytes.get(AbstractCanAddressingInformation.TARGET_ADDRESS_NAME, None)  # type: ignore  # noqa: E501
-            or from_can_id.get(AbstractCanAddressingInformation.TARGET_ADDRESS_NAME, None),
-            source_address=from_can_id.get(AbstractCanAddressingInformation.SOURCE_ADDRESS_NAME, None),  # type: ignore
-            address_extension=from_data_bytes.get(AbstractCanAddressingInformation.ADDRESS_EXTENSION_NAME, None))  # type: ignore  # noqa: E501
+        items_names = (AbstractCanAddressingInformation.ADDRESSING_TYPE_NAME,
+                       AbstractCanAddressingInformation.TARGET_ADDRESS_NAME,
+                       AbstractCanAddressingInformation.SOURCE_ADDRESS_NAME,
+                       AbstractCanAddressingInformation.ADDRESS_EXTENSION_NAME)
+        return {name: from_data_bytes.get(name, None) or from_can_id.get(name, None)
+                for name in items_names}  # type: ignore
 
     @classmethod
     def decode_ai_data_bytes(cls,
@@ -166,12 +166,12 @@ def decode_ai_data_bytes(cls,
                                    ai_data_bytes=ai_data_bytes)
         if addressing_format in {CanAddressingFormat.NORMAL_11BIT_ADDRESSING,
                                  CanAddressingFormat.NORMAL_FIXED_ADDRESSING}:
-            return cls.DataBytesAIParamsAlias()
+            return {}
         if addressing_format == CanAddressingFormat.EXTENDED_ADDRESSING:
-            return cls.DataBytesAIParamsAlias(target_address=ai_data_bytes[0])
+            return {AbstractCanAddressingInformation.TARGET_ADDRESS_NAME: ai_data_bytes[0]}  # type: ignore
         if addressing_format in {CanAddressingFormat.MIXED_11BIT_ADDRESSING,
                                  CanAddressingFormat.MIXED_29BIT_ADDRESSING}:
-            return cls.DataBytesAIParamsAlias(address_extension=ai_data_bytes[0])
+            return {AbstractCanAddressingInformation.ADDRESS_EXTENSION_NAME:  ai_data_bytes[0]}  # type: ignore
         raise NotImplementedError(f"Missing implementation for: {addressing_format}")
 
     @classmethod
@@ -197,11 +197,11 @@ def encode_ai_data_bytes(cls,
                                  CanAddressingFormat.NORMAL_FIXED_ADDRESSING):
             return []
         if addressing_format == CanAddressingFormat.EXTENDED_ADDRESSING:
-            validate_raw_byte(target_address)  # type: ignore
+            validate_raw_byte(target_address)
             return [target_address]  # type: ignore
         if addressing_format in (CanAddressingFormat.MIXED_11BIT_ADDRESSING,
                                  CanAddressingFormat.MIXED_29BIT_ADDRESSING):
-            validate_raw_byte(address_extension)  # type: ignore
+            validate_raw_byte(address_extension)
             return [address_extension]  # type: ignore
         raise NotImplementedError(f"Missing implementation for: {addressing_format}")
 

uds/can/extended_addressing_information.py

@@ -46,15 +46,16 @@ def validate_packet_ai(cls,
         if (source_address, address_extension) != (None, None):
             raise UnusedArgumentError("Values of Source Address and Address Extension are not supported by "
                                       "Extended Addressing format and all must be None.")
-        addressing_type = AddressingType.validate_member(addressing_type)
-        CanIdHandler.validate_can_id(can_id)  # type: ignore
-        validate_raw_byte(target_address)  # type: ignore
+        AddressingType.validate_member(addressing_type)
+        CanIdHandler.validate_can_id(can_id)
+        validate_raw_byte(target_address)
         if not CanIdHandler.is_extended_addressed_can_id(can_id):  # type: ignore
             raise InconsistentArgumentsError(f"Provided value of CAN ID is not compatible with "
                                              f"Extended Addressing Format. Actual value: {can_id}")
-        return PacketAIParamsAlias(addressing_format=CanAddressingFormat.EXTENDED_ADDRESSING,
-                                   addressing_type=addressing_type,
-                                   can_id=can_id,  # type: ignore
-                                   target_address=target_address,
-                                   source_address=source_address,
-                                   address_extension=address_extension)
+        return PacketAIParamsAlias(
+            addressing_format=CanAddressingFormat.EXTENDED_ADDRESSING,
+            addressing_type=addressing_type,
+            can_id=can_id,  # type: ignore
+            target_address=target_address,
+            source_address=source_address,
+            address_extension=address_extension)

uds/can/flow_control.py

@@ -9,7 +9,7 @@
 
 __all__ = ["CanFlowStatus", "CanSTminTranslator", "CanFlowControlHandler", "UnrecognizedSTminWarning"]
 
-from typing import Optional
+from typing import Optional, Any
 from warnings import warn
 
 from aenum import unique
@@ -119,7 +119,7 @@ def encode(cls, time_value: TimeMillisecondsAlias) -> int:
         raise ValueError(f"Provided value is out of valid STmin ranges. Actual value: {time_value}")
 
     @classmethod
-    def is_time_value(cls, value: TimeMillisecondsAlias) -> bool:
+    def is_time_value(cls, value: Any) -> bool:
         """
         Check if provided value is a valid time value of STmin.
 
@@ -425,8 +425,8 @@ def __encode_valid_flow_status(cls,
         """
         CanFlowStatus.validate_member(flow_status)
         if flow_status == CanFlowStatus.ContinueToSend:
-            validate_raw_byte(block_size)  # type: ignore
-            validate_raw_byte(st_min)  # type: ignore
+            validate_raw_byte(block_size)
+            validate_raw_byte(st_min)
         else:
             if block_size is not None:
                 validate_raw_byte(block_size)

uds/can/frame_fields.py

@@ -9,7 +9,7 @@
 
 __all__ = ["CanIdHandler", "CanDlcHandler", "DEFAULT_FILLER_BYTE"]
 
-from typing import Optional, Tuple, Set, TypedDict, Dict
+from typing import Any, Optional, Tuple, Set, TypedDict, Dict
 from bisect import bisect_left
 
 from uds.transmission_attributes import AddressingType
@@ -95,9 +95,9 @@ def decode_can_id(cls, addressing_format: CanAddressingFormat, can_id: int) -> C
         if addressing_format in (CanAddressingFormat.NORMAL_11BIT_ADDRESSING,
                                  CanAddressingFormat.EXTENDED_ADDRESSING,
                                  CanAddressingFormat.MIXED_11BIT_ADDRESSING):
-            return cls.CanIdAIAlias(addressing_type=None,
-                                    target_address=None,
-                                    source_address=None)  # no addressing information can be decoded
+            return {cls.ADDRESSING_TYPE_NAME: None,  # type: ignore
+                    cls.TARGET_ADDRESS_NAME: None,
+                    cls.SOURCE_ADDRESS_NAME: None}  # no addressing information can be decoded
         raise NotImplementedError(f"Unknown addressing format value was provided: {addressing_format}")
 
     @classmethod
@@ -122,13 +122,15 @@ def decode_normal_fixed_addressed_can_id(cls, can_id: int) -> CanIdAIAlias:
         source_address = can_id & 0xFF
         can_id_offset = can_id & (~0xFFFF)  # value with Target Address and Source Address information erased
         if can_id_offset == cls.NORMAL_FIXED_PHYSICAL_ADDRESSING_OFFSET:
-            return cls.CanIdAIAlias(addressing_type=AddressingType.PHYSICAL,
-                                    target_address=target_address,
-                                    source_address=source_address)
+            addressing_type = AddressingType(AddressingType.PHYSICAL)
+            return {cls.ADDRESSING_TYPE_NAME: addressing_type,  # type: ignore
+                    cls.TARGET_ADDRESS_NAME: target_address,
+                    cls.SOURCE_ADDRESS_NAME: source_address}
         if can_id_offset == cls.NORMAL_FIXED_FUNCTIONAL_ADDRESSING_OFFSET:
-            return cls.CanIdAIAlias(addressing_type=AddressingType.FUNCTIONAL,
-                                    target_address=target_address,
-                                    source_address=source_address)
+            addressing_type = AddressingType(AddressingType.FUNCTIONAL)
+            return {cls.ADDRESSING_TYPE_NAME: addressing_type,  # type: ignore
+                    cls.TARGET_ADDRESS_NAME: target_address,
+                    cls.SOURCE_ADDRESS_NAME: source_address}
         raise NotImplementedError("CAN ID in Normal Fixed Addressing format was provided, but cannot be handled."
                                   f"Actual value: {can_id}")
 
@@ -154,13 +156,15 @@ def decode_mixed_addressed_29bit_can_id(cls, can_id: int) -> CanIdAIAlias:
         source_address = can_id & 0xFF
         can_id_offset = can_id & (~0xFFFF)  # value with Target Address and Source Address information erased
         if can_id_offset == cls.MIXED_29BIT_PHYSICAL_ADDRESSING_OFFSET:
-            return cls.CanIdAIAlias(addressing_type=AddressingType.PHYSICAL,
-                                    target_address=target_address,
-                                    source_address=source_address)
+            addressing_type = AddressingType(AddressingType.PHYSICAL)
+            return {cls.ADDRESSING_TYPE_NAME: addressing_type,  # type: ignore
+                    cls.TARGET_ADDRESS_NAME: target_address,
+                    cls.SOURCE_ADDRESS_NAME: source_address}
         if can_id_offset == cls.MIXED_29BIT_FUNCTIONAL_ADDRESSING_OFFSET:
-            return cls.CanIdAIAlias(addressing_type=AddressingType.FUNCTIONAL,
-                                    target_address=target_address,
-                                    source_address=source_address)
+            addressing_type = AddressingType(AddressingType.FUNCTIONAL)
+            return {cls.ADDRESSING_TYPE_NAME: addressing_type,  # type: ignore
+                    cls.TARGET_ADDRESS_NAME: target_address,
+                    cls.SOURCE_ADDRESS_NAME: source_address}
         raise NotImplementedError("CAN ID in Normal Fixed Addressing format was provided, but cannot be handled."
                                   f"Actual value: {can_id}")
 
@@ -372,7 +376,7 @@ def is_extended_can_id(cls, can_id: int) -> bool:
         return isinstance(can_id, int) and cls.MIN_EXTENDED_VALUE <= can_id <= cls.MAX_EXTENDED_VALUE
 
     @classmethod
-    def validate_can_id(cls, value: int, extended_can_id: Optional[bool] = None) -> None:
+    def validate_can_id(cls, value: Any, extended_can_id: Optional[bool] = None) -> None:
         """
         Validate whether provided value is either Standard or Extended CAN ID.
 
@@ -481,7 +485,7 @@ def is_can_fd_specific_dlc(cls, dlc: int) -> bool:
         return dlc in cls.__DLC_SPECIFIC_FOR_CAN_FD
 
     @classmethod
-    def validate_dlc(cls, value: int) -> None:
+    def validate_dlc(cls, value: Any) -> None:
         """
         Validate whether the provided value is a valid value of CAN DLC.
 
@@ -496,7 +500,7 @@ def validate_dlc(cls, value: int) -> None:
             raise ValueError(f"Provided value is out of DLC values range. Actual value: {value}")
 
     @classmethod
-    def validate_data_bytes_number(cls, value: int, exact_value: bool = True) -> None:
+    def validate_data_bytes_number(cls, value: Any, exact_value: bool = True) -> None:
         """
         Validate whether provided value is a valid number of data bytes that might be carried a CAN frame.