reworked aliases

All enum aliases reworked.
Removed unused aliases.

Author: mdabrowski1990

tests/software_tests/message/test_uds_message.py

@@ -78,7 +78,7 @@ def test_addressing_type__get(self, value):
 
     def test_addressing_type__set(self, example_addressing_type):
         UdsMessage.addressing_type.fset(self.mock_uds_message, value=example_addressing_type)
-        assert self.mock_uds_message._UdsMessage__addressing_type == example_addressing_type
+        assert self.mock_uds_message._UdsMessage__addressing_type == self.mock_validate_addressing.return_value
         self.mock_validate_addressing.assert_called_once_with(example_addressing_type)
 
     def test_addressing_type__set_second_call(self, example_addressing_type):

tests/software_tests/packet/test_abstract_packet.py

@@ -65,7 +65,7 @@ def test_direction__get(self, direction):
 
     def test_direction__set(self, example_transmission_direction):
         AbstractUdsPacketRecord.direction.fset(self.mock_packet_record, value=example_transmission_direction)
-        assert self.mock_packet_record._AbstractUdsPacketRecord__direction == example_transmission_direction
+        assert self.mock_packet_record._AbstractUdsPacketRecord__direction == self.mock_validate_direction.return_value
         self.mock_validate_direction.assert_called_once_with(example_transmission_direction)
 
     @pytest.mark.parametrize("old_value", [None, 0, "some direction"])

tests/software_tests/packet/test_can_packet_record.py

@@ -60,18 +60,16 @@ def test_init(self, frame, direction, addressing_type, addressing_format, transm
                                  addressing_format=addressing_format,
                                  transmission_time=transmission_time)
         assert self.mock_can_packet_record._CanPacketRecord__addressing_type \
-               == self.mock_addressing_type_class.return_value
+               == self.mock_addressing_type_class.validate_member.return_value
         assert self.mock_can_packet_record._CanPacketRecord__addressing_format \
-               == self.mock_can_addressing_format_class.return_value
+               == self.mock_can_addressing_format_class.validate_member.return_value
         self.mock_abstract_uds_packet_record_init.assert_called_once_with(frame=frame,
                                                                           direction=direction,
                                                                           transmission_time=transmission_time)
         self.mock_can_packet_record._CanPacketRecord__assess_packet_type.assert_called_once_with()
         self.mock_can_packet_record._CanPacketRecord__assess_ai_attributes.assert_called_once_with()
         self.mock_addressing_type_class.validate_member.assert_called_once_with(addressing_type)
-        self.mock_addressing_type_class.assert_called_once_with(addressing_type)
         self.mock_can_addressing_format_class.validate_member.assert_called_once_with(addressing_format)
-        self.mock_can_addressing_format_class.assert_called_once_with(addressing_format)
 
     # raw_frame_data
 
@@ -160,12 +158,12 @@ def test_assess_packet_type(self, raw_frame_data, ai_data_bytes_number):
         self.mock_can_packet_record.raw_frame_data = raw_frame_data
         self.mock_can_ai_class.get_ai_data_bytes_number.return_value = ai_data_bytes_number
         assert CanPacketRecord._CanPacketRecord__assess_packet_type(self=self.mock_can_packet_record) is None
-        assert self.mock_can_packet_record._CanPacketRecord__packet_type == self.mock_can_packet_type_class.return_value
+        assert self.mock_can_packet_record._CanPacketRecord__packet_type \
+               == self.mock_can_packet_type_class.validate_member.return_value
         n_pci_value = raw_frame_data[ai_data_bytes_number] >> 4
         self.mock_can_ai_class.get_ai_data_bytes_number.assert_called_once_with(
             self.mock_can_packet_record.addressing_format)
         self.mock_can_packet_type_class.validate_member.assert_called_once_with(n_pci_value)
-        self.mock_can_packet_type_class.assert_called_once_with(n_pci_value)
 
     # __assess_ai_attributes
 
@@ -195,8 +193,8 @@ def test_assess_ai_attributes(self, addressing_format, can_id, raw_frame_data,
         assert CanPacketRecord._CanPacketRecord__assess_ai_attributes(self=self.mock_can_packet_record) is None
         self.mock_can_ai_class.get_ai_data_bytes_number.assert_called_once_with(addressing_format)
         self.mock_can_ai_class.decode_packet_ai.assert_called_once_with(addressing_format=addressing_format,
-                                                                         can_id=can_id,
-                                                                         ai_data_bytes=raw_frame_data[:ai_data_bytes_number])
+                                                                        can_id=can_id,
+                                                                        ai_data_bytes=raw_frame_data[:ai_data_bytes_number])
         assert self.mock_can_packet_record._CanPacketRecord__target_address == decoded_ai["target_address"]
         assert self.mock_can_packet_record._CanPacketRecord__source_address == decoded_ai["source_address"]
         assert self.mock_can_packet_record._CanPacketRecord__address_extension == decoded_ai["address_extension"]

uds/can/__init__.py

@@ -25,4 +25,4 @@
 from .single_frame import CanSingleFrameHandler
 from .first_frame import CanFirstFrameHandler
 from .consecutive_frame import CanConsecutiveFrameHandler
-from .flow_control import CanFlowControlHandler, CanFlowStatus, CanFlowStatusAlias, CanSTminTranslator
+from .flow_control import CanFlowControlHandler, CanFlowStatus, CanSTminTranslator

uds/can/abstract_addressing_information.py

@@ -6,7 +6,7 @@
 from abc import ABC, abstractmethod
 from copy import deepcopy
 
-from uds.transmission_attributes import AddressingTypeAlias, AddressingType
+from uds.transmission_attributes import AddressingType
 from .addressing_format import CanAddressingFormat
 from .frame_fields import CanIdHandler
 
@@ -15,7 +15,7 @@ class PacketAIParamsAlias(TypedDict):
     """Alias of :ref:`Addressing Information <knowledge-base-n-ai>` parameters of CAN packets stream."""
 
     addressing_format: CanAddressingFormat
-    addressing_type: AddressingTypeAlias
+    addressing_type: AddressingType
     can_id: int
     target_address: Optional[int]
     source_address: Optional[int]
@@ -25,7 +25,7 @@ class PacketAIParamsAlias(TypedDict):
 class AbstractCanAddressingInformation(ABC):
     """Abstract definition of CAN Entity (either server or client) Addressing Information."""
 
-    ADDRESSING_FORMAT_NAME: str = "addressing_format"
+    ADDRESSING_FORMAT_NAME: str = "addressing_format"  # noqa: F841
     """Name of :ref:`CAN Addressing Format <knowledge-base-can-addressing>` parameter in Addressing Information."""
     ADDRESSING_TYPE_NAME: str = CanIdHandler.ADDRESSING_TYPE_NAME
     """Name of :ref:`Addressing Type <knowledge-base-can-addressing>` parameter in Addressing Information."""
@@ -135,7 +135,7 @@ def tx_packets_functional_ai(self, value: InputAIParamsAlias):
     @classmethod
     @abstractmethod
     def validate_packet_ai(cls,
-                           addressing_type: AddressingTypeAlias,
+                           addressing_type: AddressingType,
                            can_id: Optional[int] = None,
                            target_address: Optional[int] = None,
                            source_address: Optional[int] = None,

uds/can/addressing_format.py

@@ -1,6 +1,6 @@
 """Implementation of CAN Addressing Formats."""
 
-__all__: "CanAddressingFormat" = ["CanAddressingFormat"]
+__all__ = ["CanAddressingFormat"]
 
 from aenum import unique, StrEnum
 
@@ -16,17 +16,17 @@ class CanAddressingFormat(StrEnum, ValidatedEnum):
     :ref:`Network Address Information (N_AI) <knowledge-base-n-ai>` is provided.
     """
 
-    NORMAL_11BIT_ADDRESSING: "CanAddressingFormat" = "Normal 11-bit Addressing"
+    NORMAL_11BIT_ADDRESSING: "CanAddressingFormat" = "Normal 11-bit Addressing"  # type: ignore
     """:ref:`Normal addressing <knowledge-base-can-normal-addressing>` format that uses 11-bit CAN Identifiers."""
-    NORMAL_FIXED_ADDRESSING: "CanAddressingFormat" = "Normal Fixed Addressing"
+    NORMAL_FIXED_ADDRESSING: "CanAddressingFormat" = "Normal Fixed Addressing"  # type: ignore
     """:ref:`Normal fixed addressing <knowledge-base-can-normal-fixed-addressing>` format.
     It is a subformat of :ref:`Normal addressing <knowledge-base-can-normal-addressing>` which uses 29-bit
     CAN Identifiers only."""
-    EXTENDED_ADDRESSING: "CanAddressingFormat" = "Extended Addressing"
+    EXTENDED_ADDRESSING: "CanAddressingFormat" = "Extended Addressing"  # type: ignore
     """:ref:`Extended addressing <knowledge-base-can-extended-addressing>` format."""
-    MIXED_11BIT_ADDRESSING: "CanAddressingFormat" = "Mixed 11-bit Addressing"
+    MIXED_11BIT_ADDRESSING: "CanAddressingFormat" = "Mixed 11-bit Addressing"  # type: ignore
     """:ref:`Mixed addressing with 11-bit CAN ID <knowledge-base-can-mixed-11-bit-addressing>` format.
     It is a subformat of :ref:`mixed addressing <knowledge-base-can-mixed-addressing>`."""
-    MIXED_29BIT_ADDRESSING: "CanAddressingFormat" = "Mixed 29-bit Addressing"
+    MIXED_29BIT_ADDRESSING: "CanAddressingFormat" = "Mixed 29-bit Addressing"  # type: ignore
     """:ref:`Mixed addressing with 29-bit CAN ID <knowledge-base-can-mixed-29-bit-addressing>` format.
     It is a subformat of :ref:`mixed addressing <knowledge-base-can-mixed-addressing>`."""

uds/can/addressing_information.py

@@ -10,7 +10,7 @@
 
 from uds.utilities import InconsistentArgumentsError, \
     RawBytesAlias, RawBytesListAlias, validate_raw_byte, validate_raw_bytes
-from uds.transmission_attributes import AddressingTypeAlias
+from uds.transmission_attributes import AddressingType
 from .addressing_format import CanAddressingFormat
 from .frame_fields import CanIdHandler
 from .abstract_addressing_information import AbstractCanAddressingInformation, PacketAIParamsAlias
@@ -37,7 +37,15 @@ class DataBytesAIParamsAlias(TypedDict, total=False):
         target_address: int
         address_extension: int
 
-    def __new__(cls,
+    class DecodedAIParamsAlias(TypedDict, total=True):
+        """Alias of :ref:`Addressing Information <knowledge-base-n-ai>` parameters encoded in CAN ID and data field."""
+
+        addressing_type: Optional[AddressingType]
+        target_address: Optional[int]
+        source_address: Optional[int]
+        address_extension: Optional[int]
+
+    def __new__(cls,  # type: ignore
                 addressing_format: CanAddressingFormat,
                 rx_physical: AbstractCanAddressingInformation.InputAIParamsAlias,
                 tx_physical: AbstractCanAddressingInformation.InputAIParamsAlias,
@@ -61,7 +69,7 @@ def __new__(cls,
     @classmethod
     def validate_packet_ai(cls,
                            addressing_format: CanAddressingFormat,
-                           addressing_type: AddressingTypeAlias,
+                           addressing_type: AddressingType,
                            can_id: Optional[int] = None,
                            target_address: Optional[int] = None,
                            source_address: Optional[int] = None,
@@ -109,7 +117,7 @@ def validate_ai_data_bytes(cls, addressing_format: CanAddressingFormat, ai_data_
     def decode_packet_ai(cls,
                          addressing_format: CanAddressingFormat,
                          can_id: int,
-                         ai_data_bytes: RawBytesAlias) -> PacketAIParamsAlias:
+                         ai_data_bytes: RawBytesAlias) -> DecodedAIParamsAlias:
         """
         Decode Addressing Information parameters from CAN ID and data bytes.
 
@@ -129,11 +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)
-        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 names}  # TODO: update to match return annotation
+        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,
@@ -159,10 +168,10 @@ def decode_ai_data_bytes(cls,
                                  CanAddressingFormat.NORMAL_FIXED_ADDRESSING}:
             return {}
         if addressing_format == CanAddressingFormat.EXTENDED_ADDRESSING:
-            return {AbstractCanAddressingInformation.TARGET_ADDRESS_NAME: 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 {AbstractCanAddressingInformation.ADDRESS_EXTENSION_NAME:  ai_data_bytes[0]}
+            return {AbstractCanAddressingInformation.ADDRESS_EXTENSION_NAME:  ai_data_bytes[0]}  # type: ignore
         raise NotImplementedError(f"Missing implementation for: {addressing_format}")
 
     @classmethod
@@ -189,11 +198,11 @@ def encode_ai_data_bytes(cls,
             return []
         if addressing_format == CanAddressingFormat.EXTENDED_ADDRESSING:
             validate_raw_byte(target_address)
-            return [target_address]
+            return [target_address]  # type: ignore
         if addressing_format in (CanAddressingFormat.MIXED_11BIT_ADDRESSING,
                                  CanAddressingFormat.MIXED_29BIT_ADDRESSING):
             validate_raw_byte(address_extension)
-            return [address_extension]
+            return [address_extension]  # type: ignore
         raise NotImplementedError(f"Missing implementation for: {addressing_format}")
 
     @classmethod

uds/can/extended_addressing_information.py

@@ -5,7 +5,7 @@
 from typing import Optional
 
 from uds.utilities import InconsistentArgumentsError, UnusedArgumentError, validate_raw_byte
-from uds.transmission_attributes import AddressingType, AddressingTypeAlias
+from uds.transmission_attributes import AddressingType
 from .addressing_format import CanAddressingFormat
 from .frame_fields import CanIdHandler
 from .abstract_addressing_information import AbstractCanAddressingInformation, PacketAIParamsAlias
@@ -24,12 +24,11 @@ def addressing_format(self) -> CanAddressingFormat:
 
     @classmethod
     def validate_packet_ai(cls,
-                           addressing_type: AddressingTypeAlias,
+                           addressing_type: AddressingType,
                            can_id: Optional[int] = None,
                            target_address: Optional[int] = None,
                            source_address: Optional[int] = None,
-                           address_extension: Optional[int] = None
-                           ) -> PacketAIParamsAlias:
+                           address_extension: Optional[int] = None) -> PacketAIParamsAlias:
         """
         Validate Addressing Information parameters of a CAN packet that uses Extended Addressing format.
 

uds/can/flow_control.py

@@ -7,10 +7,9 @@
  - :ref:`Separation Time minimum (STmin) <knowledge-base-can-st-min>`
 """
 
-__all__ = ["CanFlowStatus", "CanFlowStatusAlias", "CanSTminTranslator", "CanFlowControlHandler",
-           "UnrecognizedSTminWarning"]
+__all__ = ["CanFlowStatus", "CanSTminTranslator", "CanFlowControlHandler", "UnrecognizedSTminWarning"]
 
-from typing import Union, Optional, Any
+from typing import Optional, Any
 from warnings import warn
 
 from aenum import unique
@@ -42,18 +41,14 @@ class CanFlowStatus(NibbleEnum, ValidatedEnum):
     Consecutive Frames transmission.
     """
 
-    ContinueToSend = 0x0
+    ContinueToSend: "CanFlowStatus" = 0x0  # type: ignore
     """Asks to resume Consecutive Frames transmission."""
-    Wait = 0x1  # noqa: F841
+    Wait: "CanFlowStatus" = 0x1  # type: ignore  # noqa: F841
     """Asks to pause Consecutive Frames transmission."""
-    Overflow = 0x2  # noqa: F841
+    Overflow: "CanFlowStatus" = 0x2  # type: ignore  # noqa: F841
     """Asks to abort transmission of a diagnostic message."""
 
 
-CanFlowStatusAlias = Union[CanFlowStatus, int]
-"""Typing alias that describes :class:`~uds.can.flow_control.CanFlowStatus` member."""
-
-
 class CanSTminTranslator:
     """
     Helper class that provides STmin values mapping.
@@ -178,7 +173,7 @@ class CanFlowControlHandler:
     @classmethod
     def create_valid_frame_data(cls, *,
                                 addressing_format: CanAddressingFormat,
-                                flow_status: CanFlowStatusAlias,
+                                flow_status: CanFlowStatus,
                                 block_size: Optional[int] = None,
                                 st_min: Optional[int] = None,
                                 dlc: Optional[int] = None,
@@ -237,7 +232,7 @@ def create_valid_frame_data(cls, *,
     @classmethod
     def create_any_frame_data(cls, *,
                               addressing_format: CanAddressingFormat,
-                              flow_status: CanFlowStatusAlias,
+                              flow_status: CanFlowStatus,
                               dlc: int,
                               block_size: Optional[int] = None,
                               st_min: Optional[int] = None,
@@ -305,7 +300,7 @@ def is_flow_control(cls, addressing_format: CanAddressingFormat, raw_frame_data:
     @classmethod
     def decode_flow_status(cls,
                            addressing_format: CanAddressingFormat,
-                           raw_frame_data: RawBytesAlias) -> CanFlowStatusAlias:
+                           raw_frame_data: RawBytesAlias) -> CanFlowStatus:
         """
         Extract Flow Status value from Flow Control data bytes.
 
@@ -410,7 +405,7 @@ def validate_frame_data(cls, addressing_format: CanAddressingFormat, raw_frame_d
 
     @classmethod
     def __encode_valid_flow_status(cls,
-                                   flow_status: CanFlowStatusAlias,
+                                   flow_status: CanFlowStatus,
                                    block_size: Optional[int] = None,
                                    st_min: Optional[int] = None,
                                    filler_byte: int = DEFAULT_FILLER_BYTE) -> RawBytesListAlias: